fidl_next_fuchsia_driver_framework/

fidl_next_fuchsia_driver_framework.rs

// DO NOT EDIT: This file is machine-generated by fidlgen
#![warn(clippy::all)]
#![allow(unused_parens, unused_variables, unused_mut, unused_imports, unreachable_code)]

pub type NodePropertyKeyUint = u32;

/// The wire type corresponding to [`NodePropertyKeyUint`].
pub type WireNodePropertyKeyUint = ::fidl_next::WireU32;

pub type NodePropertyKeyString = String;

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

#[derive(Clone, Debug)]
pub enum NodePropertyKey {
    IntValue(u32),

    StringValue(String),
}

impl ::fidl_next::Encodable for NodePropertyKey {
    type Encoded = WireNodePropertyKey<'static>;
}

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

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

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

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

        Ok(())
    }
}

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

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

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for NodePropertyKey {
    type EncodedOption = WireOptionalNodePropertyKey<'static>;
}

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

unsafe impl ::fidl_next::Wire for WireNodePropertyKey<'static> {
    type Decoded<'de> = WireNodePropertyKey<'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 node_property_key {
    pub enum Ref<'de> {
        IntValue(&'de ::fidl_next::WireU32),

        StringValue(&'de ::fidl_next::WireString<'de>),
    }
}

impl<'de> WireNodePropertyKey<'de> {
    pub fn as_ref(&self) -> crate::node_property_key::Ref<'_> {
        match self.raw.ordinal() {
            1 => crate::node_property_key::Ref::IntValue(unsafe {
                self.raw.get().deref_unchecked::<::fidl_next::WireU32>()
            }),

            2 => crate::node_property_key::Ref::StringValue(unsafe {
                self.raw.get().deref_unchecked::<::fidl_next::WireString<'_>>()
            }),

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

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

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

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

            ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
        }

        Ok(())
    }
}

impl<'de> ::core::fmt::Debug for WireNodePropertyKey<'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::WireU32>().fmt(f) },
            2 => unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireString<'_>>().fmt(f) },
            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

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

unsafe impl ::fidl_next::Wire for WireOptionalNodePropertyKey<'static> {
    type Decoded<'de> = WireOptionalNodePropertyKey<'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> WireOptionalNodePropertyKey<'de> {
    pub fn is_some(&self) -> bool {
        self.raw.is_some()
    }

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

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

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

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

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

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

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

        Ok(())
    }
}

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

#[doc = " Represents a bind rule condition.\n"]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u32)]
pub enum Condition {
    Unknown = 0,
    Accept = 1,
    Reject = 2,
}

impl ::fidl_next::Encodable for Condition {
    type Encoded = WireCondition;
}
impl ::std::convert::TryFrom<u32> for Condition {
    type Error = ::fidl_next::UnknownStrictEnumMemberError;
    fn try_from(value: u32) -> Result<Self, Self::Error> {
        match value {
            0 => Ok(Self::Unknown),
            1 => Ok(Self::Accept),
            2 => Ok(Self::Reject),

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

unsafe impl<___E> ::fidl_next::Encode<___E> for Condition
where
    ___E: ?Sized,
{
    #[inline]
    fn encode(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::EncodeRef::encode_ref(&self, encoder, out)
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for Condition
where
    ___E: ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireCondition { value } = out);
        let _ = value.write(::fidl_next::WireU32::from(match *self {
            Self::Unknown => 0,

            Self::Accept => 1,

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

        Ok(())
    }
}

impl ::core::convert::From<WireCondition> for Condition {
    fn from(wire: WireCondition) -> Self {
        match u32::from(wire.value) {
            0 => Self::Unknown,

            1 => Self::Accept,

            2 => Self::Reject,

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

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

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

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

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

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

impl WireCondition {
    pub const UNKNOWN: WireCondition = WireCondition { value: ::fidl_next::WireU32(0) };

    pub const ACCEPT: WireCondition = WireCondition { value: ::fidl_next::WireU32(1) };

    pub const REJECT: WireCondition = WireCondition { value: ::fidl_next::WireU32(2) };
}

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

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

        Ok(())
    }
}

impl ::core::convert::From<Condition> for WireCondition {
    fn from(natural: Condition) -> Self {
        match natural {
            Condition::Unknown => WireCondition::UNKNOWN,

            Condition::Accept => WireCondition::ACCEPT,

            Condition::Reject => WireCondition::REJECT,
        }
    }
}

pub type NodePropertyValueUint = u32;

/// The wire type corresponding to [`NodePropertyValueUint`].
pub type WireNodePropertyValueUint = ::fidl_next::WireU32;

pub type NodePropertyValueString = String;

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

pub type NodePropertyValueBool = bool;

/// The wire type corresponding to [`NodePropertyValueBool`].
pub type WireNodePropertyValueBool = bool;

pub type NodePropertyValueEnum = String;

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

#[derive(Clone, Debug)]
pub enum NodePropertyValue {
    IntValue(u32),

    StringValue(String),

    BoolValue(bool),

    EnumValue(String),

    UnknownOrdinal_(u64),
}

impl ::fidl_next::Encodable for NodePropertyValue {
    type Encoded = WireNodePropertyValue<'static>;
}

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

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

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

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

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

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

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

        Ok(())
    }
}

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

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

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

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

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

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for NodePropertyValue {
    type EncodedOption = WireOptionalNodePropertyValue<'static>;
}

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            _ => (),
        }
    }
}

unsafe impl ::fidl_next::Wire for WireNodePropertyValue<'static> {
    type Decoded<'de> = WireNodePropertyValue<'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 node_property_value {
    pub enum Ref<'de> {
        IntValue(&'de ::fidl_next::WireU32),

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

        BoolValue(&'de bool),

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

        UnknownOrdinal_(u64),
    }
}

impl<'de> WireNodePropertyValue<'de> {
    pub fn as_ref(&self) -> crate::node_property_value::Ref<'_> {
        match self.raw.ordinal() {
            1 => crate::node_property_value::Ref::IntValue(unsafe {
                self.raw.get().deref_unchecked::<::fidl_next::WireU32>()
            }),

            2 => crate::node_property_value::Ref::StringValue(unsafe {
                self.raw.get().deref_unchecked::<::fidl_next::WireString<'_>>()
            }),

            3 => crate::node_property_value::Ref::BoolValue(unsafe {
                self.raw.get().deref_unchecked::<bool>()
            }),

            4 => crate::node_property_value::Ref::EnumValue(unsafe {
                self.raw.get().deref_unchecked::<::fidl_next::WireString<'_>>()
            }),

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

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

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

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

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

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

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

        Ok(())
    }
}

impl<'de> ::core::fmt::Debug for WireNodePropertyValue<'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::WireU32>().fmt(f) },
            2 => unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireString<'_>>().fmt(f) },
            3 => unsafe { self.raw.get().deref_unchecked::<bool>().fmt(f) },
            4 => unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireString<'_>>().fmt(f) },
            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

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

unsafe impl ::fidl_next::Wire for WireOptionalNodePropertyValue<'static> {
    type Decoded<'de> = WireOptionalNodePropertyValue<'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> WireOptionalNodePropertyValue<'de> {
    pub fn is_some(&self) -> bool {
        self.raw.is_some()
    }

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

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

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

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

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

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

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

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

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

        Ok(())
    }
}

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

pub const MAX_PROPERTY_COUNT: u8 = 64;

#[doc = " Represents a bind rule in a parent specification.\n"]
#[derive(Clone, Debug)]
pub struct BindRule {
    pub key: crate::NodePropertyKey,

    pub condition: crate::Condition,

    pub values: Vec<crate::NodePropertyValue>,
}

impl ::fidl_next::Encodable for BindRule {
    type Encoded = WireBindRule<'static>;
}

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

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

            } = out;
        }

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

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

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

        Ok(())
    }
}

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

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

            } = out;
        }

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

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

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

        Ok(())
    }
}

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

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

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

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

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

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

/// The wire type corresponding to [`BindRule`].
#[derive(Debug)]
#[repr(C)]
pub struct WireBindRule<'de> {
    pub key: crate::WireNodePropertyKey<'de>,

    pub condition: crate::WireCondition,

    pub values: ::fidl_next::WireVector<'de, crate::WireNodePropertyValue<'de>>,
}

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

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        unsafe {
            out.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
        }
    }
}

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

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

            } = slot;
        }

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

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

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

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

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

        Ok(())
    }
}

#[doc = " Represents a bind rule in a parent specification.\n"]
#[derive(Clone, Debug)]
pub struct BindRule2 {
    pub key: String,

    pub condition: crate::Condition,

    pub values: Vec<crate::NodePropertyValue>,
}

impl ::fidl_next::Encodable for BindRule2 {
    type Encoded = WireBindRule2<'static>;
}

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

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

            } = out;
        }

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

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

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

        Ok(())
    }
}

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

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

            } = out;
        }

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

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

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

        Ok(())
    }
}

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

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

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

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

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

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

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

    pub condition: crate::WireCondition,

    pub values: ::fidl_next::WireVector<'de, crate::WireNodePropertyValue<'de>>,
}

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

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        unsafe {
            out.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
        }
    }
}

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

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

            } = slot;
        }

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

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

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

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

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

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

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

        Ok(())
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u32)]
pub enum BusType {
    Platform = 1,
    Acpi = 2,
    DeviceTree = 3,
    Pci = 4,
    Usb = 5,
    Gpio = 6,
    I2C = 7,
    Spi = 8,
    Sdio = 9,
    Uart = 10,
    Spmi = 11,
    UnknownOrdinal_(u32),
}

impl ::fidl_next::Encodable for BusType {
    type Encoded = WireBusType;
}
impl ::std::convert::From<u32> for BusType {
    fn from(value: u32) -> Self {
        match value {
            1 => Self::Platform,
            2 => Self::Acpi,
            3 => Self::DeviceTree,
            4 => Self::Pci,
            5 => Self::Usb,
            6 => Self::Gpio,
            7 => Self::I2C,
            8 => Self::Spi,
            9 => Self::Sdio,
            10 => Self::Uart,
            11 => Self::Spmi,

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

unsafe impl<___E> ::fidl_next::Encode<___E> for BusType
where
    ___E: ?Sized,
{
    #[inline]
    fn encode(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::EncodeRef::encode_ref(&self, encoder, out)
    }
}

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

            Self::Acpi => 2,

            Self::DeviceTree => 3,

            Self::Pci => 4,

            Self::Usb => 5,

            Self::Gpio => 6,

            Self::I2C => 7,

            Self::Spi => 8,

            Self::Sdio => 9,

            Self::Uart => 10,

            Self::Spmi => 11,

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

        Ok(())
    }
}

impl ::core::convert::From<WireBusType> for BusType {
    fn from(wire: WireBusType) -> Self {
        match u32::from(wire.value) {
            1 => Self::Platform,

            2 => Self::Acpi,

            3 => Self::DeviceTree,

            4 => Self::Pci,

            5 => Self::Usb,

            6 => Self::Gpio,

            7 => Self::I2C,

            8 => Self::Spi,

            9 => Self::Sdio,

            10 => Self::Uart,

            11 => Self::Spmi,

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

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

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

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

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

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

impl WireBusType {
    pub const PLATFORM: WireBusType = WireBusType { value: ::fidl_next::WireU32(1) };

    pub const ACPI: WireBusType = WireBusType { value: ::fidl_next::WireU32(2) };

    pub const DEVICE_TREE: WireBusType = WireBusType { value: ::fidl_next::WireU32(3) };

    pub const PCI: WireBusType = WireBusType { value: ::fidl_next::WireU32(4) };

    pub const USB: WireBusType = WireBusType { value: ::fidl_next::WireU32(5) };

    pub const GPIO: WireBusType = WireBusType { value: ::fidl_next::WireU32(6) };

    pub const I2_C: WireBusType = WireBusType { value: ::fidl_next::WireU32(7) };

    pub const SPI: WireBusType = WireBusType { value: ::fidl_next::WireU32(8) };

    pub const SDIO: WireBusType = WireBusType { value: ::fidl_next::WireU32(9) };

    pub const UART: WireBusType = WireBusType { value: ::fidl_next::WireU32(10) };

    pub const SPMI: WireBusType = WireBusType { value: ::fidl_next::WireU32(11) };
}

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

impl ::core::convert::From<BusType> for WireBusType {
    fn from(natural: BusType) -> Self {
        match natural {
            BusType::Platform => WireBusType::PLATFORM,

            BusType::Acpi => WireBusType::ACPI,

            BusType::DeviceTree => WireBusType::DEVICE_TREE,

            BusType::Pci => WireBusType::PCI,

            BusType::Usb => WireBusType::USB,

            BusType::Gpio => WireBusType::GPIO,

            BusType::I2C => WireBusType::I2_C,

            BusType::Spi => WireBusType::SPI,

            BusType::Sdio => WireBusType::SDIO,

            BusType::Uart => WireBusType::UART,

            BusType::Spmi => WireBusType::SPMI,

            BusType::UnknownOrdinal_(value) => {
                WireBusType { value: ::fidl_next::WireU32::from(value) }
            }
        }
    }
}

pub const MAX_DEVICE_ADDRESS_ARRAY_LEN: u32 = 10;

pub const MAX_DEVICE_ADDRESS_STR_LEN: u32 = 32;

#[derive(Clone, Debug)]
pub enum DeviceAddress {
    IntValue(u8),

    ArrayIntValue(Vec<u8>),

    CharIntValue(String),

    ArrayCharIntValue(Vec<String>),

    StringValue(String),

    UnknownOrdinal_(u64),
}

impl ::fidl_next::Encodable for DeviceAddress {
    type Encoded = WireDeviceAddress<'static>;
}

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

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

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

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

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

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

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

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

        Ok(())
    }
}

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

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

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

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

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

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

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for DeviceAddress {
    type EncodedOption = WireOptionalDeviceAddress<'static>;
}

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            _ => (),
        }
    }
}

unsafe impl ::fidl_next::Wire for WireDeviceAddress<'static> {
    type Decoded<'de> = WireDeviceAddress<'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 device_address {
    pub enum Ref<'de> {
        IntValue(&'de u8),

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

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

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

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

        UnknownOrdinal_(u64),
    }
}

impl<'de> WireDeviceAddress<'de> {
    pub fn as_ref(&self) -> crate::device_address::Ref<'_> {
        match self.raw.ordinal() {
            1 => crate::device_address::Ref::IntValue(unsafe {
                self.raw.get().deref_unchecked::<u8>()
            }),

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

            3 => crate::device_address::Ref::CharIntValue(unsafe {
                self.raw.get().deref_unchecked::<::fidl_next::WireString<'_>>()
            }),

            4 => {
                crate::device_address::Ref::ArrayCharIntValue(unsafe {
                    self.raw.get().deref_unchecked::<::fidl_next::WireVector<'_, ::fidl_next::WireString<'_>>>()
                })
            }

            5 => crate::device_address::Ref::StringValue(unsafe {
                self.raw.get().deref_unchecked::<::fidl_next::WireString<'_>>()
            }),

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

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

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

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

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

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

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

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

        Ok(())
    }
}

impl<'de> ::core::fmt::Debug for WireDeviceAddress<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        match self.raw.ordinal() {
            1 => unsafe { self.raw.get().deref_unchecked::<u8>().fmt(f) },
            2 => unsafe {
                self.raw.get().deref_unchecked::<::fidl_next::WireVector<'_, u8>>().fmt(f)
            },
            3 => unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireString<'_>>().fmt(f) },
            4 => unsafe {
                self.raw
                    .get()
                    .deref_unchecked::<::fidl_next::WireVector<'_, ::fidl_next::WireString<'_>>>()
                    .fmt(f)
            },
            5 => unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireString<'_>>().fmt(f) },
            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

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

unsafe impl ::fidl_next::Wire for WireOptionalDeviceAddress<'static> {
    type Decoded<'de> = WireOptionalDeviceAddress<'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> WireOptionalDeviceAddress<'de> {
    pub fn is_some(&self) -> bool {
        self.raw.is_some()
    }

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

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

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

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

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

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

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

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

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

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

        Ok(())
    }
}

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

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u32)]
pub enum DeviceAddressStability {
    UnstableBetweenDriverRestart = 0,
    UnstableBetweenBoot = 1,
    UnstableBetweenSoftwareUpdate = 2,
    Stable = 3,
    UnknownOrdinal_(u32),
}

impl ::fidl_next::Encodable for DeviceAddressStability {
    type Encoded = WireDeviceAddressStability;
}
impl ::std::convert::From<u32> for DeviceAddressStability {
    fn from(value: u32) -> Self {
        match value {
            0 => Self::UnstableBetweenDriverRestart,
            1 => Self::UnstableBetweenBoot,
            2 => Self::UnstableBetweenSoftwareUpdate,
            3 => Self::Stable,

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

unsafe impl<___E> ::fidl_next::Encode<___E> for DeviceAddressStability
where
    ___E: ?Sized,
{
    #[inline]
    fn encode(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::EncodeRef::encode_ref(&self, encoder, out)
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for DeviceAddressStability
where
    ___E: ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireDeviceAddressStability { value } = out);
        let _ = value.write(::fidl_next::WireU32::from(match *self {
            Self::UnstableBetweenDriverRestart => 0,

            Self::UnstableBetweenBoot => 1,

            Self::UnstableBetweenSoftwareUpdate => 2,

            Self::Stable => 3,

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

        Ok(())
    }
}

impl ::core::convert::From<WireDeviceAddressStability> for DeviceAddressStability {
    fn from(wire: WireDeviceAddressStability) -> Self {
        match u32::from(wire.value) {
            0 => Self::UnstableBetweenDriverRestart,

            1 => Self::UnstableBetweenBoot,

            2 => Self::UnstableBetweenSoftwareUpdate,

            3 => Self::Stable,

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

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

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

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

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

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

impl WireDeviceAddressStability {
    pub const UNSTABLE_BETWEEN_DRIVER_RESTART: WireDeviceAddressStability =
        WireDeviceAddressStability { value: ::fidl_next::WireU32(0) };

    pub const UNSTABLE_BETWEEN_BOOT: WireDeviceAddressStability =
        WireDeviceAddressStability { value: ::fidl_next::WireU32(1) };

    pub const UNSTABLE_BETWEEN_SOFTWARE_UPDATE: WireDeviceAddressStability =
        WireDeviceAddressStability { value: ::fidl_next::WireU32(2) };

    pub const STABLE: WireDeviceAddressStability =
        WireDeviceAddressStability { value: ::fidl_next::WireU32(3) };
}

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

impl ::core::convert::From<DeviceAddressStability> for WireDeviceAddressStability {
    fn from(natural: DeviceAddressStability) -> Self {
        match natural {
            DeviceAddressStability::UnstableBetweenDriverRestart => {
                WireDeviceAddressStability::UNSTABLE_BETWEEN_DRIVER_RESTART
            }

            DeviceAddressStability::UnstableBetweenBoot => {
                WireDeviceAddressStability::UNSTABLE_BETWEEN_BOOT
            }

            DeviceAddressStability::UnstableBetweenSoftwareUpdate => {
                WireDeviceAddressStability::UNSTABLE_BETWEEN_SOFTWARE_UPDATE
            }

            DeviceAddressStability::Stable => WireDeviceAddressStability::STABLE,

            DeviceAddressStability::UnknownOrdinal_(value) => {
                WireDeviceAddressStability { value: ::fidl_next::WireU32::from(value) }
            }
        }
    }
}

#[derive(Clone, Debug, Default)]
pub struct BusInfo {
    pub bus: Option<crate::BusType>,

    pub address: Option<crate::DeviceAddress>,

    pub address_stability: Option<crate::DeviceAddressStability>,
}

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for BusInfo {
    type Encoded = WireBusInfo<'static>;
}

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

        let max_ord = self.__max_ordinal();

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

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

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

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

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

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

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

        Ok(())
    }
}

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

        let max_ord = self.__max_ordinal();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

                    Ok(())
                }

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

                    Ok(())
                }

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

                    Ok(())
                }

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

impl<'de> WireBusInfo<'de> {
    pub fn bus(&self) -> Option<&crate::WireBusType> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

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

impl<'de> ::core::fmt::Debug for WireBusInfo<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("BusInfo")
            .field("bus", &self.bus())
            .field("address", &self.address())
            .field("address_stability", &self.address_stability())
            .finish()
    }
}

#[doc = " The type of Fuchsia package that a driver component is inside of.\n More details about the various package categories are available at:\n https://fuchsia.dev/fuchsia-src/concepts/packages/package#types_of_packages\n"]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u8)]
pub enum DriverPackageType {
    Boot = 0,
    Base = 1,
    Cached = 2,
    Universe = 3,
    UnknownOrdinal_(u8),
}

impl ::fidl_next::Encodable for DriverPackageType {
    type Encoded = WireDriverPackageType;
}
impl ::std::convert::From<u8> for DriverPackageType {
    fn from(value: u8) -> Self {
        match value {
            0 => Self::Boot,
            1 => Self::Base,
            2 => Self::Cached,
            3 => Self::Universe,

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

unsafe impl<___E> ::fidl_next::Encode<___E> for DriverPackageType
where
    ___E: ?Sized,
{
    #[inline]
    fn encode(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::EncodeRef::encode_ref(&self, encoder, out)
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for DriverPackageType
where
    ___E: ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireDriverPackageType { value } = out);
        let _ = value.write(u8::from(match *self {
            Self::Boot => 0,

            Self::Base => 1,

            Self::Cached => 2,

            Self::Universe => 3,

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

        Ok(())
    }
}

impl ::core::convert::From<WireDriverPackageType> for DriverPackageType {
    fn from(wire: WireDriverPackageType) -> Self {
        match u8::from(wire.value) {
            0 => Self::Boot,

            1 => Self::Base,

            2 => Self::Cached,

            3 => Self::Universe,

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

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

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

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

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

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

impl WireDriverPackageType {
    pub const BOOT: WireDriverPackageType = WireDriverPackageType { value: 0 };

    pub const BASE: WireDriverPackageType = WireDriverPackageType { value: 1 };

    pub const CACHED: WireDriverPackageType = WireDriverPackageType { value: 2 };

    pub const UNIVERSE: WireDriverPackageType = WireDriverPackageType { value: 3 };
}

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

impl ::core::convert::From<DriverPackageType> for WireDriverPackageType {
    fn from(natural: DriverPackageType) -> Self {
        match natural {
            DriverPackageType::Boot => WireDriverPackageType::BOOT,

            DriverPackageType::Base => WireDriverPackageType::BASE,

            DriverPackageType::Cached => WireDriverPackageType::CACHED,

            DriverPackageType::Universe => WireDriverPackageType::UNIVERSE,

            DriverPackageType::UnknownOrdinal_(value) => {
                WireDriverPackageType { value: u8::from(value) }
            }
        }
    }
}

#[doc = " Device categories as provided in the driver\'s component manifest.\n"]
#[derive(Clone, Debug, Default)]
pub struct DeviceCategory {
    pub category: Option<String>,

    pub subcategory: Option<String>,
}

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

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

        0
    }
}

impl ::fidl_next::Encodable for DeviceCategory {
    type Encoded = WireDeviceCategory<'static>;
}

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

        let max_ord = self.__max_ordinal();

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

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

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

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

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

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

        Ok(())
    }
}

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

        let max_ord = self.__max_ordinal();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

                    Ok(())
                }

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

                    Ok(())
                }

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

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

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

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

#[doc = " General information for a driver, used with both composite and normal drivers.\n"]
#[derive(Clone, Debug, Default)]
pub struct DriverInfo {
    pub url: Option<String>,

    pub name: Option<String>,

    pub colocate: Option<bool>,

    pub package_type: Option<crate::DriverPackageType>,

    pub is_fallback: Option<bool>,

    pub device_categories: Option<Vec<crate::DeviceCategory>>,

    pub bind_rules_bytecode: Option<Vec<u8>>,

    pub driver_framework_version: Option<u8>,

    pub is_disabled: Option<bool>,
}

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

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

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

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

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

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

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

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

        if self.is_disabled.is_some() {
            return 9;
        }

        0
    }
}

impl ::fidl_next::Encodable for DriverInfo {
    type Encoded = WireDriverInfo<'static>;
}

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

        let max_ord = self.__max_ordinal();

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

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

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

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

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

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

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

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

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

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

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

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

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

        Ok(())
    }
}

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

        let max_ord = self.__max_ordinal();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        let device_categories = wire.table.get(6);

        let bind_rules_bytecode = wire.table.get(7);

        let driver_framework_version = wire.table.get(8);

        let is_disabled = wire.table.get(9);

        Self {


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


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


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


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


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


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


                bind_rules_bytecode: bind_rules_bytecode.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::WireVector<'de, u8>>() }
                )),


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


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

        }
    }
}

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


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


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


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


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


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


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


                bind_rules_bytecode: wire.table.get(7)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::WireVector<'de, u8>>() }
                    )),


                driver_framework_version: wire.table.get(8)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<u8>() }
                    )),


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

        }
    }
}

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

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

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

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

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

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

        let _ = self.table.get(6).map(|envelope| unsafe {
            envelope
                .read_unchecked::<::fidl_next::WireVector<'de, crate::WireDeviceCategory<'de>>>()
        });

        let _ = self.table.get(7).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next::WireVector<'de, u8>>()
        });

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

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

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

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

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

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

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

                    Ok(())
                }

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

                    Ok(())
                }

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

                    Ok(())
                }

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

                    Ok(())
                }

                5 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, bool>(slot.as_mut(), decoder)?;

                    Ok(())
                }

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

                    Ok(())
                }

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

                    Ok(())
                }

                8 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, u8>(slot.as_mut(), decoder)?;

                    Ok(())
                }

                9 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, bool>(slot.as_mut(), decoder)?;

                    Ok(())
                }

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

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

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

    pub fn colocate(&self) -> Option<&bool> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }

    pub fn package_type(&self) -> Option<&crate::WireDriverPackageType> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }

    pub fn is_fallback(&self) -> Option<&bool> {
        unsafe { Some(self.table.get(5)?.deref_unchecked()) }
    }

    pub fn device_categories(
        &self,
    ) -> Option<&::fidl_next::WireVector<'de, crate::WireDeviceCategory<'de>>> {
        unsafe { Some(self.table.get(6)?.deref_unchecked()) }
    }

    pub fn bind_rules_bytecode(&self) -> Option<&::fidl_next::WireVector<'de, u8>> {
        unsafe { Some(self.table.get(7)?.deref_unchecked()) }
    }

    pub fn driver_framework_version(&self) -> Option<&u8> {
        unsafe { Some(self.table.get(8)?.deref_unchecked()) }
    }

    pub fn is_disabled(&self) -> Option<&bool> {
        unsafe { Some(self.table.get(9)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireDriverInfo<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("DriverInfo")
            .field("url", &self.url())
            .field("name", &self.name())
            .field("colocate", &self.colocate())
            .field("package_type", &self.package_type())
            .field("is_fallback", &self.is_fallback())
            .field("device_categories", &self.device_categories())
            .field("bind_rules_bytecode", &self.bind_rules_bytecode())
            .field("driver_framework_version", &self.driver_framework_version())
            .field("is_disabled", &self.is_disabled())
            .finish()
    }
}

#[doc = " Information for a composite driver.\n"]
#[derive(Clone, Debug, Default)]
pub struct CompositeDriverInfo {
    pub composite_name: Option<String>,

    pub driver_info: Option<crate::DriverInfo>,
}

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

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

        0
    }
}

impl ::fidl_next::Encodable for CompositeDriverInfo {
    type Encoded = WireCompositeDriverInfo<'static>;
}

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

        let max_ord = self.__max_ordinal();

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

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

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

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

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

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

        Ok(())
    }
}

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

        let max_ord = self.__max_ordinal();

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

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

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

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

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

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

        Ok(())
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

                    Ok(())
                }

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

                    Ok(())
                }

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

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

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

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

#[doc = " Information for a composite driver that has matched with a composite.\n"]
#[derive(Clone, Debug, Default)]
pub struct CompositeDriverMatch {
    pub composite_driver: Option<crate::CompositeDriverInfo>,

    pub parent_names: Option<Vec<String>>,

    pub primary_parent_index: Option<u32>,
}

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for CompositeDriverMatch {
    type Encoded = WireCompositeDriverMatch<'static>;
}

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

        let max_ord = self.__max_ordinal();

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

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

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

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

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

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

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

        Ok(())
    }
}

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

        let max_ord = self.__max_ordinal();

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

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

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

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

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

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

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

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

        Self {


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


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


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

        }
    }
}

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


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


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


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

        }
    }
}

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

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

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

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

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

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

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

                    Ok(())
                }

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

                    Ok(())
                }

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

                    Ok(())
                }

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

impl<'de> WireCompositeDriverMatch<'de> {
    pub fn composite_driver(&self) -> Option<&crate::WireCompositeDriverInfo<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

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

impl<'de> ::core::fmt::Debug for WireCompositeDriverMatch<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("CompositeDriverMatch")
            .field("composite_driver", &self.composite_driver())
            .field("parent_names", &self.parent_names())
            .field("primary_parent_index", &self.primary_parent_index())
            .finish()
    }
}

#[doc = " Definition of a property for a node. A property is commonly used to match a\n node to a driver for driver binding.\n"]
#[derive(Clone, Debug)]
pub struct NodeProperty {
    pub key: crate::NodePropertyKey,

    pub value: crate::NodePropertyValue,
}

impl ::fidl_next::Encodable for NodeProperty {
    type Encoded = WireNodeProperty<'static>;
}

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

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

            } = out;
        }

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

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

        Ok(())
    }
}

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

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

            } = out;
        }

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

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

        Ok(())
    }
}

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

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

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

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

/// The wire type corresponding to [`NodeProperty`].
#[derive(Debug)]
#[repr(C)]
pub struct WireNodeProperty<'de> {
    pub key: crate::WireNodePropertyKey<'de>,

    pub value: crate::WireNodePropertyValue<'de>,
}

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

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

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

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

            } = slot;
        }

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

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

        Ok(())
    }
}

#[doc = " Specification for a node that parents the composite node created from the\n composite node specification.\n"]
#[derive(Clone, Debug)]
pub struct ParentSpec {
    pub bind_rules: Vec<crate::BindRule>,

    pub properties: Vec<crate::NodeProperty>,
}

impl ::fidl_next::Encodable for ParentSpec {
    type Encoded = WireParentSpec<'static>;
}

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

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

            } = out;
        }

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

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

        Ok(())
    }
}

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

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

            } = out;
        }

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

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

        Ok(())
    }
}

impl<'de> ::fidl_next::FromWire<WireParentSpec<'de>> for ParentSpec {
    #[inline]
    fn from_wire(wire: WireParentSpec<'de>) -> Self {
        Self {
            bind_rules: ::fidl_next::FromWire::from_wire(wire.bind_rules),

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

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

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

/// The wire type corresponding to [`ParentSpec`].
#[derive(Debug)]
#[repr(C)]
pub struct WireParentSpec<'de> {
    pub bind_rules: ::fidl_next::WireVector<'de, crate::WireBindRule<'de>>,

    pub properties: ::fidl_next::WireVector<'de, crate::WireNodeProperty<'de>>,
}

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

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

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

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

            } = slot;
        }

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

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

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

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

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

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

        Ok(())
    }
}

#[derive(Clone, Debug)]
pub struct NodeProperty2 {
    pub key: String,

    pub value: crate::NodePropertyValue,
}

impl ::fidl_next::Encodable for NodeProperty2 {
    type Encoded = WireNodeProperty2<'static>;
}

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

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

            } = out;
        }

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

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

        Ok(())
    }
}

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

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

            } = out;
        }

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

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

        Ok(())
    }
}

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

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

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

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

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

    pub value: crate::WireNodePropertyValue<'de>,
}

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

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

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

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

            } = slot;
        }

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

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

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

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

        Ok(())
    }
}

#[doc = " Specification for a node that parents the composite node created from the\n composite node specification.\n"]
#[derive(Clone, Debug)]
pub struct ParentSpec2 {
    pub bind_rules: Vec<crate::BindRule2>,

    pub properties: Vec<crate::NodeProperty2>,
}

impl ::fidl_next::Encodable for ParentSpec2 {
    type Encoded = WireParentSpec2<'static>;
}

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

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

            } = out;
        }

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

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

        Ok(())
    }
}

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

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

            } = out;
        }

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

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

        Ok(())
    }
}

impl<'de> ::fidl_next::FromWire<WireParentSpec2<'de>> for ParentSpec2 {
    #[inline]
    fn from_wire(wire: WireParentSpec2<'de>) -> Self {
        Self {
            bind_rules: ::fidl_next::FromWire::from_wire(wire.bind_rules),

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

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

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

/// The wire type corresponding to [`ParentSpec2`].
#[derive(Debug)]
#[repr(C)]
pub struct WireParentSpec2<'de> {
    pub bind_rules: ::fidl_next::WireVector<'de, crate::WireBindRule2<'de>>,

    pub properties: ::fidl_next::WireVector<'de, crate::WireNodeProperty2<'de>>,
}

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

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

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

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

            } = slot;
        }

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

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

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

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

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

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

        Ok(())
    }
}

#[doc = " Struct that represents a composite node specification.\n"]
#[derive(Clone, Debug, Default)]
pub struct CompositeNodeSpec {
    pub name: Option<String>,

    pub parents: Option<Vec<crate::ParentSpec>>,

    pub parents2: Option<Vec<crate::ParentSpec2>>,
}

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for CompositeNodeSpec {
    type Encoded = WireCompositeNodeSpec<'static>;
}

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

        let max_ord = self.__max_ordinal();

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

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

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

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

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

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

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

        Ok(())
    }
}

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

        let max_ord = self.__max_ordinal();

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

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

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

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

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

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

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

        Ok(())
    }
}

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

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

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

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

        Self {


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


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


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

        }
    }
}

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


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


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


                parents2: wire.table.get(3)
                    .map(|envelope| ::fidl_next::FromWireRef::from_wire_ref(
                        unsafe { envelope.deref_unchecked::<::fidl_next::WireVector<'de, crate::WireParentSpec2<'de>>>() }
                    )),

        }
    }
}

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

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

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

        let _ = self.table.get(3).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireParentSpec2<'de>>>()
        });
    }
}

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

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

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

                    Ok(())
                }

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

                    Ok(())
                }

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

                    Ok(())
                }

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

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

    pub fn parents(&self) -> Option<&::fidl_next::WireVector<'de, crate::WireParentSpec<'de>>> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn parents2(&self) -> Option<&::fidl_next::WireVector<'de, crate::WireParentSpec2<'de>>> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }
}

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

#[doc = " Information for a composite that is defined by a composite node spec.\n"]
#[derive(Clone, Debug, Default)]
pub struct CompositeInfo {
    pub spec: Option<crate::CompositeNodeSpec>,

    pub matched_driver: Option<crate::CompositeDriverMatch>,
}

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

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

        0
    }
}

impl ::fidl_next::Encodable for CompositeInfo {
    type Encoded = WireCompositeInfo<'static>;
}

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

        let max_ord = self.__max_ordinal();

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

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

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

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

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

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

        Ok(())
    }
}

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

        let max_ord = self.__max_ordinal();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

                    Ok(())
                }

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

                    Ok(())
                }

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

impl<'de> WireCompositeInfo<'de> {
    pub fn spec(&self) -> Option<&crate::WireCompositeNodeSpec<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

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

pub type CompositeNodeManagerAddSpecResponse = ();

/// The wire type corresponding to [`CompositeNodeManagerAddSpecResponse`].
pub type WireCompositeNodeManagerAddSpecResponse = ();

#[doc = " Error codes for the CompositeNodeManager protocol.\n"]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u32)]
pub enum CompositeNodeSpecError {
    MissingArgs = 1,
    EmptyNodes = 2,
    AlreadyExists = 3,
    DriverIndexFailure = 4,
    DuplicateParents = 5,
    UnknownOrdinal_(u32),
}

impl ::fidl_next::Encodable for CompositeNodeSpecError {
    type Encoded = WireCompositeNodeSpecError;
}
impl ::std::convert::From<u32> for CompositeNodeSpecError {
    fn from(value: u32) -> Self {
        match value {
            1 => Self::MissingArgs,
            2 => Self::EmptyNodes,
            3 => Self::AlreadyExists,
            4 => Self::DriverIndexFailure,
            5 => Self::DuplicateParents,

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

unsafe impl<___E> ::fidl_next::Encode<___E> for CompositeNodeSpecError
where
    ___E: ?Sized,
{
    #[inline]
    fn encode(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::EncodeRef::encode_ref(&self, encoder, out)
    }
}

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

            Self::EmptyNodes => 2,

            Self::AlreadyExists => 3,

            Self::DriverIndexFailure => 4,

            Self::DuplicateParents => 5,

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

        Ok(())
    }
}

impl ::core::convert::From<WireCompositeNodeSpecError> for CompositeNodeSpecError {
    fn from(wire: WireCompositeNodeSpecError) -> Self {
        match u32::from(wire.value) {
            1 => Self::MissingArgs,

            2 => Self::EmptyNodes,

            3 => Self::AlreadyExists,

            4 => Self::DriverIndexFailure,

            5 => Self::DuplicateParents,

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

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

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

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

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

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

impl WireCompositeNodeSpecError {
    pub const MISSING_ARGS: WireCompositeNodeSpecError =
        WireCompositeNodeSpecError { value: ::fidl_next::WireU32(1) };

    pub const EMPTY_NODES: WireCompositeNodeSpecError =
        WireCompositeNodeSpecError { value: ::fidl_next::WireU32(2) };

    pub const ALREADY_EXISTS: WireCompositeNodeSpecError =
        WireCompositeNodeSpecError { value: ::fidl_next::WireU32(3) };

    pub const DRIVER_INDEX_FAILURE: WireCompositeNodeSpecError =
        WireCompositeNodeSpecError { value: ::fidl_next::WireU32(4) };

    pub const DUPLICATE_PARENTS: WireCompositeNodeSpecError =
        WireCompositeNodeSpecError { value: ::fidl_next::WireU32(5) };
}

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

impl ::core::convert::From<CompositeNodeSpecError> for WireCompositeNodeSpecError {
    fn from(natural: CompositeNodeSpecError) -> Self {
        match natural {
            CompositeNodeSpecError::MissingArgs => WireCompositeNodeSpecError::MISSING_ARGS,

            CompositeNodeSpecError::EmptyNodes => WireCompositeNodeSpecError::EMPTY_NODES,

            CompositeNodeSpecError::AlreadyExists => WireCompositeNodeSpecError::ALREADY_EXISTS,

            CompositeNodeSpecError::DriverIndexFailure => {
                WireCompositeNodeSpecError::DRIVER_INDEX_FAILURE
            }

            CompositeNodeSpecError::DuplicateParents => {
                WireCompositeNodeSpecError::DUPLICATE_PARENTS
            }

            CompositeNodeSpecError::UnknownOrdinal_(value) => {
                WireCompositeNodeSpecError { value: ::fidl_next::WireU32::from(value) }
            }
        }
    }
}

/// The type corresponding to the CompositeNodeManager protocol.
#[doc = " Protocol through which board drivers can create composite node specs.\n\n Composite node specs are created at runtime to dynamically bridge the\n static bind rules of a composite driver with the dynamic bind properties\n of nodes in the system so that the driver bind rules are more generic and reusable.\n"]
#[derive(Debug)]
pub struct CompositeNodeManager;

impl ::fidl_next::Discoverable for CompositeNodeManager {
    const PROTOCOL_NAME: &'static str = "composite_node_manager";
}

pub mod composite_node_manager {
    pub mod prelude {
        pub use crate::{
            composite_node_manager, CompositeNodeManager, CompositeNodeManagerClientHandler,
            CompositeNodeManagerClientSender, CompositeNodeManagerServerHandler,
            CompositeNodeManagerServerSender,
        };

        pub use crate::CompositeNodeManagerAddSpecResponse;

        pub use crate::CompositeNodeSpec;

        pub use crate::CompositeNodeSpecError;
    }

    pub struct AddSpec;

    impl ::fidl_next::Method for AddSpec {
        const ORDINAL: u64 = 5930736293275290740;

        type Protocol = crate::CompositeNodeManager;

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

        type Response = ::fidl_next::WireFlexibleResult<
            'static,
            crate::WireCompositeNodeManagerAddSpecResponse,
            crate::WireCompositeNodeSpecError,
        >;
    }
}

/// A helper trait for the `CompositeNodeManager` client sender.
pub trait CompositeNodeManagerClientSender {
    type Transport: ::fidl_next::Transport;

    #[doc = " Adds the given composite node specification to the driver framework.\n"]
    fn add_spec<___R>(
        &self,
        request: ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, composite_node_manager::AddSpec>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireCompositeNodeSpec<'static>,
        >;
}

impl<___T> CompositeNodeManagerClientSender
    for ::fidl_next::ClientSender<___T, CompositeNodeManager>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;

    #[doc = " Adds the given composite node specification to the driver framework.\n"]
    fn add_spec<___R>(
        &self,
        request: ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, composite_node_manager::AddSpec>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireCompositeNodeSpec<'static>,
        >,
    {
        self.as_untyped()
            .send_two_way(5930736293275290740, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }
}

/// A client handler for the CompositeNodeManager protocol.
///
/// See [`CompositeNodeManager`] for more details.
pub trait CompositeNodeManagerClientHandler<___T: ::fidl_next::Transport> {
    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ClientSender<___T, CompositeNodeManager>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for CompositeNodeManager
where
    ___T: ::fidl_next::Transport,
    ___H: CompositeNodeManagerClientHandler<___T>,

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

/// A helper trait for the `CompositeNodeManager` server sender.
pub trait CompositeNodeManagerServerSender {
    type Transport: ::fidl_next::Transport;
}

impl<___T> CompositeNodeManagerServerSender
    for ::fidl_next::ServerSender<___T, CompositeNodeManager>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;
}

/// A server handler for the CompositeNodeManager protocol.
///
/// See [`CompositeNodeManager`] for more details.
pub trait CompositeNodeManagerServerHandler<___T: ::fidl_next::Transport> {
    #[doc = " Adds the given composite node specification to the driver framework.\n"]
    fn add_spec(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, CompositeNodeManager>,

        request: ::fidl_next::Request<___T, composite_node_manager::AddSpec>,

        responder: ::fidl_next::Responder<composite_node_manager::AddSpec>,
    );

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, CompositeNodeManager>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for CompositeNodeManager
where
    ___T: ::fidl_next::Transport,
    ___H: CompositeNodeManagerServerHandler<___T>,

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

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

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

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

#[doc = " A parent to a composite that is defined by a composite node spec.\n"]
#[derive(Clone, Debug, Default)]
pub struct CompositeParent {
    pub composite: Option<crate::CompositeInfo>,

    pub index: Option<u32>,
}

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

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

        0
    }
}

impl ::fidl_next::Encodable for CompositeParent {
    type Encoded = WireCompositeParent<'static>;
}

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

        let max_ord = self.__max_ordinal();

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

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

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

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

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

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

        Ok(())
    }
}

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

        let max_ord = self.__max_ordinal();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

                    Ok(())
                }

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

                    Ok(())
                }

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

impl<'de> WireCompositeParent<'de> {
    pub fn composite(&self) -> Option<&crate::WireCompositeInfo<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

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

#[derive(Debug, Default)]
pub struct DevfsAddArgs {
    pub connector: Option<
        ::fidl_next::ClientEnd<
            ::fidl_next::fuchsia::zx::Channel,
            ::fidl_next_fuchsia_device_fs::Connector,
        >,
    >,

    pub class_name: Option<String>,

    pub inspect: Option<::fidl_next::fuchsia::zx::Handle>,

    pub connector_supports: Option<::fidl_next_fuchsia_device_fs::ConnectionType>,

    pub controller_connector: Option<
        ::fidl_next::ClientEnd<
            ::fidl_next::fuchsia::zx::Channel,
            ::fidl_next_fuchsia_device_fs::Connector,
        >,
    >,
}

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

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

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for DevfsAddArgs {
    type Encoded = WireDevfsAddArgs<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for DevfsAddArgs
where
    ___E: ::fidl_next::Encoder + ?Sized,

    ___E: ::fidl_next::fuchsia::HandleEncoder,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireDevfsAddArgs { table } = out);

        let max_ord = self.__max_ordinal();

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

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

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

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

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

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

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

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

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

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

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

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

        Self {
            connector: connector.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::ClientEnd<
                        ::fidl_next::fuchsia::WireChannel,
                        ::fidl_next_fuchsia_device_fs::Connector,
                    >>()
                })
            }),

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

            inspect: inspect.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::fuchsia::WireHandle>()
                })
            }),

            connector_supports: connector_supports.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next_fuchsia_device_fs::WireConnectionType>()
                })
            }),

            controller_connector: controller_connector.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::ClientEnd<
                        ::fidl_next::fuchsia::WireChannel,
                        ::fidl_next_fuchsia_device_fs::Connector,
                    >>()
                })
            }),
        }
    }
}

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

impl<'de> Drop for WireDevfsAddArgs<'de> {
    fn drop(&mut self) {
        let _ = self.table.get(1).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next::ClientEnd<
                ::fidl_next::fuchsia::WireChannel,
                ::fidl_next_fuchsia_device_fs::Connector,
            >>()
        });

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

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

        let _ = self.table.get(4).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next_fuchsia_device_fs::WireConnectionType>()
        });

        let _ = self.table.get(5).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next::ClientEnd<
                ::fidl_next::fuchsia::WireChannel,
                ::fidl_next_fuchsia_device_fs::Connector,
            >>()
        });
    }
}

unsafe impl ::fidl_next::Wire for WireDevfsAddArgs<'static> {
    type Decoded<'de> = WireDevfsAddArgs<'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 WireDevfsAddArgs<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,

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

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

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::ClientEnd<
                            ::fidl_next::fuchsia::WireChannel,
                            ::fidl_next_fuchsia_device_fs::Connector,
                        >,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

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

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

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

                    Ok(())
                }

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

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next_fuchsia_device_fs::WireConnectionType,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                5 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::ClientEnd<
                            ::fidl_next::fuchsia::WireChannel,
                            ::fidl_next_fuchsia_device_fs::Connector,
                        >,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

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

impl<'de> WireDevfsAddArgs<'de> {
    pub fn connector(
        &self,
    ) -> Option<
        &::fidl_next::ClientEnd<
            ::fidl_next::fuchsia::WireChannel,
            ::fidl_next_fuchsia_device_fs::Connector,
        >,
    > {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

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

    pub fn connector_supports(&self) -> Option<&::fidl_next_fuchsia_device_fs::WireConnectionType> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }

    pub fn controller_connector(
        &self,
    ) -> Option<
        &::fidl_next::ClientEnd<
            ::fidl_next::fuchsia::WireChannel,
            ::fidl_next_fuchsia_device_fs::Connector,
        >,
    > {
        unsafe { Some(self.table.get(5)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireDevfsAddArgs<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("DevfsAddArgs")
            .field("connector", &self.connector())
            .field("class_name", &self.class_name())
            .field("inspect", &self.inspect())
            .field("connector_supports", &self.connector_supports())
            .field("controller_connector", &self.controller_connector())
            .finish()
    }
}

pub const MAX_SYMBOL_NAME_LENGTH: u8 = 128;

pub const MAX_SYMBOL_COUNT: u8 = 64;

pub const MAX_NAMESPACE_COUNT: u32 = 32;

pub type DriverStartResponse = ();

/// The wire type corresponding to [`DriverStartResponse`].
pub type WireDriverStartResponse = ();

pub const MAX_NODE_NAME_LENGTH: u8 = 128;

pub type NodeName = String;

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

pub type NodePropertyVector = Vec<crate::NodeProperty>;

/// The wire type corresponding to [`NodePropertyVector`].
pub type WireNodePropertyVector<'de> = ::fidl_next::WireVector<'de, crate::WireNodeProperty<'de>>;

pub const MAX_OFFER_COUNT: u32 = 128;

#[doc = " Contains the node properties that belong to a node.\n"]
#[derive(Clone, Debug)]
pub struct NodePropertyEntry {
    pub name: String,

    pub properties: Vec<crate::NodeProperty>,
}

impl ::fidl_next::Encodable for NodePropertyEntry {
    type Encoded = WireNodePropertyEntry<'static>;
}

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

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

            } = out;
        }

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

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

        Ok(())
    }
}

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

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

            } = out;
        }

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

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

        Ok(())
    }
}

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

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

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

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

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

    pub properties: ::fidl_next::WireVector<'de, crate::WireNodeProperty<'de>>,
}

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

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

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

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

            } = slot;
        }

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

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

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

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

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

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

        Ok(())
    }
}

pub type NodePropertyDictionary = Vec<crate::NodePropertyEntry>;

/// The wire type corresponding to [`NodePropertyDictionary`].
pub type WireNodePropertyDictionary<'de> =
    ::fidl_next::WireVector<'de, crate::WireNodePropertyEntry<'de>>;

pub type NodeProperties = Vec<crate::NodeProperty2>;

/// The wire type corresponding to [`NodeProperties`].
pub type WireNodeProperties<'de> = ::fidl_next::WireVector<'de, crate::WireNodeProperty2<'de>>;

#[doc = " Contains the node properties that belong to a node.\n"]
#[derive(Clone, Debug)]
pub struct NodePropertyEntry2 {
    pub name: String,

    pub properties: Vec<crate::NodeProperty2>,
}

impl ::fidl_next::Encodable for NodePropertyEntry2 {
    type Encoded = WireNodePropertyEntry2<'static>;
}

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

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

            } = out;
        }

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

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

        Ok(())
    }
}

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

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

            } = out;
        }

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

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

        Ok(())
    }
}

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

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

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

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

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

    pub properties: ::fidl_next::WireVector<'de, crate::WireNodeProperty2<'de>>,
}

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

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

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

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

            } = slot;
        }

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

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

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

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

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

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

        Ok(())
    }
}

pub type NodePropertyDictionary2 = Vec<crate::NodePropertyEntry2>;

/// The wire type corresponding to [`NodePropertyDictionary2`].
pub type WireNodePropertyDictionary2<'de> =
    ::fidl_next::WireVector<'de, crate::WireNodePropertyEntry2<'de>>;

pub const MAX_MODULE_NAME_LENGTH: u8 = 128;

#[doc = " Definition of a symbol provided by a driver for a node. A symbol is local to\n a driver host.\n"]
#[derive(Clone, Debug, Default)]
pub struct NodeSymbol {
    pub name: Option<String>,

    pub address: Option<u64>,

    pub module_name: Option<String>,
}

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for NodeSymbol {
    type Encoded = WireNodeSymbol<'static>;
}

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

        let max_ord = self.__max_ordinal();

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

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

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

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

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

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

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

        Ok(())
    }
}

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

        let max_ord = self.__max_ordinal();

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

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

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

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

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

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

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

        Ok(())
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if name.len() > 128 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: name.len() as u64,
                            limit: 128,
                        });
                    }

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireU64>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let module_name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if module_name.len() > 128 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: module_name.len() as u64,
                            limit: 128,
                        });
                    }

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl<'de> WireNodeSymbol<'de> {
    pub fn name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn address(&self) -> Option<&::fidl_next::WireU64> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn module_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireNodeSymbol<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("NodeSymbol")
            .field("name", &self.name())
            .field("address", &self.address())
            .field("module_name", &self.module_name())
            .finish()
    }
}

#[derive(Clone, Debug)]
pub enum Offer {
    ZirconTransport(::fidl_next_fuchsia_component_decl::Offer),

    DriverTransport(::fidl_next_fuchsia_component_decl::Offer),

    UnknownOrdinal_(u64),
}

impl ::fidl_next::Encodable for Offer {
    type Encoded = WireOffer<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for Offer
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireOffer { raw, _phantom: _ } = out);

        match self {
            Self::ZirconTransport(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                ::fidl_next_fuchsia_component_decl::Offer,
            >(value, 1, encoder, raw)?,

            Self::DriverTransport(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                ::fidl_next_fuchsia_component_decl::Offer,
            >(value, 2, encoder, raw)?,

            Self::UnknownOrdinal_(ordinal) => {
                return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize))
            }
        }

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for Offer
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireOffer { raw, _phantom: _ } = out);

        match self {
            Self::ZirconTransport(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                &::fidl_next_fuchsia_component_decl::Offer,
            >(value, 1, encoder, raw)?,

            Self::DriverTransport(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                &::fidl_next_fuchsia_component_decl::Offer,
            >(value, 2, encoder, raw)?,

            Self::UnknownOrdinal_(ordinal) => {
                return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(*ordinal as usize))
            }
        }

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Offer {
    type EncodedOption = WireOptionalOffer<'static>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Offer
where
    ___E: ?Sized,
    Offer: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireOptionalOffer { raw, _phantom: _ } = &mut *out);

        if let Some(inner) = this {
            let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
            ::fidl_next::Encode::encode(inner, encoder, value_out)?;
        } else {
            ::fidl_next::RawWireUnion::encode_absent(raw);
        }

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for Offer
where
    ___E: ?Sized,
    Offer: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireOptionalOffer { raw, _phantom: _ } = &mut *out);

        if let Some(inner) = this {
            let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
            ::fidl_next::EncodeRef::encode_ref(inner, encoder, value_out)?;
        } else {
            ::fidl_next::RawWireUnion::encode_absent(raw);
        }

        Ok(())
    }
}

impl<'de> ::fidl_next::FromWire<WireOffer<'de>> for Offer {
    #[inline]
    fn from_wire(wire: WireOffer<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);
        match wire.raw.ordinal() {
            1 => Self::ZirconTransport(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw
                    .get()
                    .read_unchecked::<::fidl_next_fuchsia_component_decl::WireOffer<'de>>()
            })),

            2 => Self::DriverTransport(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw
                    .get()
                    .read_unchecked::<::fidl_next_fuchsia_component_decl::WireOffer<'de>>()
            })),

            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireOffer<'de>> for Offer {
    #[inline]
    fn from_wire_ref(wire: &WireOffer<'de>) -> Self {
        match wire.raw.ordinal() {
            1 => Self::ZirconTransport(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw
                    .get()
                    .deref_unchecked::<::fidl_next_fuchsia_component_decl::WireOffer<'de>>()
            })),

            2 => Self::DriverTransport(::fidl_next::FromWireRef::from_wire_ref(unsafe {
                wire.raw
                    .get()
                    .deref_unchecked::<::fidl_next_fuchsia_component_decl::WireOffer<'de>>()
            })),

            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

impl<'de> ::fidl_next::FromWireOption<WireOptionalOffer<'de>> for Box<Offer> {
    #[inline]
    fn from_wire_option(wire: WireOptionalOffer<'de>) -> Option<Self> {
        if let Some(inner) = wire.into_option() {
            Some(Box::new(::fidl_next::FromWire::from_wire(inner)))
        } else {
            None
        }
    }
}

impl<'de> ::fidl_next::FromWireOptionRef<WireOptionalOffer<'de>> for Box<Offer> {
    #[inline]
    fn from_wire_option_ref(wire: &WireOptionalOffer<'de>) -> Option<Self> {
        if let Some(inner) = wire.as_ref() {
            Some(Box::new(::fidl_next::FromWireRef::from_wire_ref(inner)))
        } else {
            None
        }
    }
}

/// The wire type corresponding to [`Offer`].
#[repr(transparent)]
pub struct WireOffer<'de> {
    raw: ::fidl_next::RawWireUnion,
    _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
}

impl<'de> Drop for WireOffer<'de> {
    fn drop(&mut self) {
        match self.raw.ordinal() {
            1 => {
                let _ = unsafe {
                    self.raw
                        .get()
                        .read_unchecked::<::fidl_next_fuchsia_component_decl::WireOffer<'de>>()
                };
            }

            2 => {
                let _ = unsafe {
                    self.raw
                        .get()
                        .read_unchecked::<::fidl_next_fuchsia_component_decl::WireOffer<'de>>()
                };
            }

            _ => (),
        }
    }
}

unsafe impl ::fidl_next::Wire for WireOffer<'static> {
    type Decoded<'de> = WireOffer<'de>;

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
        ::fidl_next::RawWireUnion::zero_padding(raw);
    }
}

pub mod offer {
    pub enum Ref<'de> {
        ZirconTransport(&'de ::fidl_next_fuchsia_component_decl::WireOffer<'de>),

        DriverTransport(&'de ::fidl_next_fuchsia_component_decl::WireOffer<'de>),

        UnknownOrdinal_(u64),
    }
}

impl<'de> WireOffer<'de> {
    pub fn as_ref(&self) -> crate::offer::Ref<'_> {
        match self.raw.ordinal() {
            1 => crate::offer::Ref::ZirconTransport(unsafe {
                self.raw
                    .get()
                    .deref_unchecked::<::fidl_next_fuchsia_component_decl::WireOffer<'_>>()
            }),

            2 => crate::offer::Ref::DriverTransport(unsafe {
                self.raw
                    .get()
                    .deref_unchecked::<::fidl_next_fuchsia_component_decl::WireOffer<'_>>()
            }),

            unknown => crate::offer::Ref::UnknownOrdinal_(unknown),
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireOffer<'static>
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::Decoder,
{
    fn decode(
        mut slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
            1 => ::fidl_next::RawWireUnion::decode_as::<
                ___D,
                ::fidl_next_fuchsia_component_decl::WireOffer<'static>,
            >(raw, decoder)?,

            2 => ::fidl_next::RawWireUnion::decode_as::<
                ___D,
                ::fidl_next_fuchsia_component_decl::WireOffer<'static>,
            >(raw, decoder)?,

            _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
        }

        Ok(())
    }
}

impl<'de> ::core::fmt::Debug for WireOffer<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        match self.raw.ordinal() {
            1 => unsafe {
                self.raw
                    .get()
                    .deref_unchecked::<::fidl_next_fuchsia_component_decl::WireOffer<'_>>()
                    .fmt(f)
            },
            2 => unsafe {
                self.raw
                    .get()
                    .deref_unchecked::<::fidl_next_fuchsia_component_decl::WireOffer<'_>>()
                    .fmt(f)
            },
            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

#[repr(transparent)]
pub struct WireOptionalOffer<'de> {
    raw: ::fidl_next::RawWireUnion,
    _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
}

unsafe impl ::fidl_next::Wire for WireOptionalOffer<'static> {
    type Decoded<'de> = WireOptionalOffer<'de>;

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
        ::fidl_next::RawWireUnion::zero_padding(raw);
    }
}

impl<'de> WireOptionalOffer<'de> {
    pub fn is_some(&self) -> bool {
        self.raw.is_some()
    }

    pub fn is_none(&self) -> bool {
        self.raw.is_none()
    }

    pub fn as_ref(&self) -> Option<&WireOffer<'de>> {
        if self.is_some() {
            Some(unsafe { &*(self as *const Self).cast() })
        } else {
            None
        }
    }

    pub fn into_option(self) -> Option<WireOffer<'de>> {
        if self.is_some() {
            Some(WireOffer { raw: self.raw, _phantom: ::core::marker::PhantomData })
        } else {
            None
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptionalOffer<'static>
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::Decoder,
{
    fn decode(
        mut slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
            1 => ::fidl_next::RawWireUnion::decode_as::<
                ___D,
                ::fidl_next_fuchsia_component_decl::WireOffer<'static>,
            >(raw, decoder)?,

            2 => ::fidl_next::RawWireUnion::decode_as::<
                ___D,
                ::fidl_next_fuchsia_component_decl::WireOffer<'static>,
            >(raw, decoder)?,

            0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
            _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
        }

        Ok(())
    }
}

impl<'de> ::core::fmt::Debug for WireOptionalOffer<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        self.as_ref().fmt(f)
    }
}

pub type NodeOffersVector = Vec<crate::Offer>;

/// The wire type corresponding to [`NodeOffersVector`].
pub type WireNodeOffersVector<'de> = ::fidl_next::WireVector<'de, crate::WireOffer<'de>>;

#[doc = " Arguments for starting a driver.\n"]
#[derive(Debug, Default)]
pub struct DriverStartArgs {
    pub node: Option<::fidl_next::ClientEnd<::fidl_next::fuchsia::zx::Channel, crate::Node>>,

    pub symbols: Option<Vec<crate::NodeSymbol>>,

    pub url: Option<String>,

    pub program: Option<::fidl_next_fuchsia_data::Dictionary>,

    pub incoming: Option<Vec<::fidl_next_fuchsia_component_runner::ComponentNamespaceEntry>>,

    pub outgoing_dir: Option<
        ::fidl_next::ServerEnd<
            ::fidl_next::fuchsia::zx::Channel,
            ::fidl_next_fuchsia_io::Directory,
        >,
    >,

    pub config: Option<::fidl_next::fuchsia::zx::Handle>,

    pub node_name: Option<String>,

    pub node_properties: Option<Vec<crate::NodePropertyEntry>>,

    pub node_offers: Option<Vec<crate::Offer>>,

    pub node_token: Option<::fidl_next::fuchsia::zx::Handle>,

    pub node_properties_2: Option<Vec<crate::NodePropertyEntry2>>,
}

impl DriverStartArgs {
    fn __max_ordinal(&self) -> usize {
        if self.node.is_some() {
            return 1;
        }

        if self.symbols.is_some() {
            return 2;
        }

        if self.url.is_some() {
            return 3;
        }

        if self.program.is_some() {
            return 4;
        }

        if self.incoming.is_some() {
            return 5;
        }

        if self.outgoing_dir.is_some() {
            return 6;
        }

        if self.config.is_some() {
            return 7;
        }

        if self.node_name.is_some() {
            return 8;
        }

        if self.node_properties.is_some() {
            return 9;
        }

        if self.node_offers.is_some() {
            return 10;
        }

        if self.node_token.is_some() {
            return 11;
        }

        if self.node_properties_2.is_some() {
            return 12;
        }

        0
    }
}

impl ::fidl_next::Encodable for DriverStartArgs {
    type Encoded = WireDriverStartArgs<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for DriverStartArgs
where
    ___E: ::fidl_next::Encoder + ?Sized,

    ___E: ::fidl_next::fuchsia::HandleEncoder,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireDriverStartArgs { 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 {
                12 => {
                    if let Some(node_properties_2) = self.node_properties_2.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            node_properties_2,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                11 => {
                    if let Some(node_token) = self.node_token.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            node_token,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                10 => {
                    if let Some(node_offers) = self.node_offers.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            node_offers,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                9 => {
                    if let Some(node_properties) = self.node_properties.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            node_properties,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                8 => {
                    if let Some(node_name) = self.node_name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            node_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                7 => {
                    if let Some(config) = self.config.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            config,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                6 => {
                    if let Some(outgoing_dir) = self.outgoing_dir.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            outgoing_dir,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                5 => {
                    if let Some(incoming) = self.incoming.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            incoming,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(program) = self.program.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            program,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(url) = self.url.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            url,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(symbols) = self.symbols.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            symbols,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(node) = self.node.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            node,
                            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<WireDriverStartArgs<'de>> for DriverStartArgs {
    #[inline]
    fn from_wire(wire: WireDriverStartArgs<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let node = wire.table.get(1);

        let symbols = wire.table.get(2);

        let url = wire.table.get(3);

        let program = wire.table.get(4);

        let incoming = wire.table.get(5);

        let outgoing_dir = wire.table.get(6);

        let config = wire.table.get(7);

        let node_name = wire.table.get(8);

        let node_properties = wire.table.get(9);

        let node_offers = wire.table.get(10);

        let node_token = wire.table.get(11);

        let node_properties_2 = wire.table.get(12);

        Self {


                node: node.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::ClientEnd<::fidl_next::fuchsia::WireChannel,crate::Node,
        >>() }
                )),


                symbols: symbols.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireNodeSymbol<'de>>>() }
                )),


                url: url.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() }
                )),


                program: program.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next_fuchsia_data::WireDictionary<'de>>() }
                )),


                incoming: incoming.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::WireVector<'de, ::fidl_next_fuchsia_component_runner::WireComponentNamespaceEntry<'de>>>() }
                )),


                outgoing_dir: outgoing_dir.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::ServerEnd<::fidl_next::fuchsia::WireChannel,::fidl_next_fuchsia_io::Directory,
        >>() }
                )),


                config: config.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::fuchsia::WireHandle>() }
                )),


                node_name: node_name.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() }
                )),


                node_properties: node_properties.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireNodePropertyEntry<'de>>>() }
                )),


                node_offers: node_offers.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireOffer<'de>>>() }
                )),


                node_token: node_token.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::fuchsia::WireHandle>() }
                )),


                node_properties_2: node_properties_2.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireNodePropertyEntry2<'de>>>() }
                )),

        }
    }
}

/// The wire type corresponding to [`DriverStartArgs`].
#[repr(C)]
pub struct WireDriverStartArgs<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireDriverStartArgs<'de> {
    fn drop(&mut self) {
        let _ = self.table.get(1)
                .map(|envelope| unsafe {
                    envelope.read_unchecked::<::fidl_next::ClientEnd<::fidl_next::fuchsia::WireChannel,crate::Node,
        >>()
                });

        let _ = self.table.get(2).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireNodeSymbol<'de>>>()
        });

        let _ = self
            .table
            .get(3)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self.table.get(4).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next_fuchsia_data::WireDictionary<'de>>()
        });

        let _ = self.table.get(5).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next::WireVector<
                'de,
                ::fidl_next_fuchsia_component_runner::WireComponentNamespaceEntry<'de>,
            >>()
        });

        let _ = self.table.get(6).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next::ServerEnd<
                ::fidl_next::fuchsia::WireChannel,
                ::fidl_next_fuchsia_io::Directory,
            >>()
        });

        let _ = self.table.get(7).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next::fuchsia::WireHandle>()
        });

        let _ = self
            .table
            .get(8)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self.table.get(9)
                .map(|envelope| unsafe {
                    envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireNodePropertyEntry<'de>>>()
                });

        let _ = self.table.get(10).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireOffer<'de>>>()
        });

        let _ = self.table.get(11).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next::fuchsia::WireHandle>()
        });

        let _ = self.table.get(12).map(|envelope| unsafe {
            envelope
                .read_unchecked::<::fidl_next::WireVector<'de, crate::WireNodePropertyEntry2<'de>>>(
                )
        });
    }
}

unsafe impl ::fidl_next::Wire for WireDriverStartArgs<'static> {
    type Decoded<'de> = WireDriverStartArgs<'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 WireDriverStartArgs<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::ClientEnd<::fidl_next::fuchsia::WireChannel, crate::Node>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::WireVector<'static, crate::WireNodeSymbol<'static>>,
                    >(slot.as_mut(), decoder)?;

                    let symbols = unsafe {
                        slot
                                            .deref_unchecked()
                                            .deref_unchecked::<
                                                ::fidl_next::WireVector<'_, crate::WireNodeSymbol<'_>>
                                            >()
                    };

                    if symbols.len() > 64 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: symbols.len() as u64,
                            limit: 64,
                        });
                    }

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let url = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if url.len() > 4096 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: url.len() as u64,
                            limit: 4096,
                        });
                    }

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next_fuchsia_data::WireDictionary<'static>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                5 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::WireVector<
                            'static,
                            ::fidl_next_fuchsia_component_runner::WireComponentNamespaceEntry<
                                'static,
                            >,
                        >,
                    >(slot.as_mut(), decoder)?;

                    let incoming = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireVector<
                            '_,
                            ::fidl_next_fuchsia_component_runner::WireComponentNamespaceEntry<'_>,
                        >>()
                    };

                    if incoming.len() > 32 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: incoming.len() as u64,
                            limit: 32,
                        });
                    }

                    Ok(())
                }

                6 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::ServerEnd<
                            ::fidl_next::fuchsia::WireChannel,
                            ::fidl_next_fuchsia_io::Directory,
                        >,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                7 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::fuchsia::WireHandle>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                8 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                9 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::WireVector<'static, crate::WireNodePropertyEntry<'static>>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                10 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::WireVector<'static, crate::WireOffer<'static>>,
                    >(slot.as_mut(), decoder)?;

                    let node_offers = unsafe {
                        slot.deref_unchecked()
                            .deref_unchecked::<::fidl_next::WireVector<'_, crate::WireOffer<'_>>>()
                    };

                    if node_offers.len() > 128 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: node_offers.len() as u64,
                            limit: 128,
                        });
                    }

                    Ok(())
                }

                11 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::fuchsia::WireHandle>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                12 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::WireVector<'static, crate::WireNodePropertyEntry2<'static>>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl<'de> WireDriverStartArgs<'de> {
    pub fn node(
        &self,
    ) -> Option<&::fidl_next::ClientEnd<::fidl_next::fuchsia::WireChannel, crate::Node>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn symbols(&self) -> Option<&::fidl_next::WireVector<'de, crate::WireNodeSymbol<'de>>> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn url(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }

    pub fn program(&self) -> Option<&::fidl_next_fuchsia_data::WireDictionary<'de>> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }

    pub fn incoming(
        &self,
    ) -> Option<
        &::fidl_next::WireVector<
            'de,
            ::fidl_next_fuchsia_component_runner::WireComponentNamespaceEntry<'de>,
        >,
    > {
        unsafe { Some(self.table.get(5)?.deref_unchecked()) }
    }

    pub fn outgoing_dir(
        &self,
    ) -> Option<
        &::fidl_next::ServerEnd<
            ::fidl_next::fuchsia::WireChannel,
            ::fidl_next_fuchsia_io::Directory,
        >,
    > {
        unsafe { Some(self.table.get(6)?.deref_unchecked()) }
    }

    pub fn config(&self) -> Option<&::fidl_next::fuchsia::WireHandle> {
        unsafe { Some(self.table.get(7)?.deref_unchecked()) }
    }

    pub fn node_name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(8)?.deref_unchecked()) }
    }

    pub fn node_properties(
        &self,
    ) -> Option<&::fidl_next::WireVector<'de, crate::WireNodePropertyEntry<'de>>> {
        unsafe { Some(self.table.get(9)?.deref_unchecked()) }
    }

    pub fn node_offers(&self) -> Option<&::fidl_next::WireVector<'de, crate::WireOffer<'de>>> {
        unsafe { Some(self.table.get(10)?.deref_unchecked()) }
    }

    pub fn node_token(&self) -> Option<&::fidl_next::fuchsia::WireHandle> {
        unsafe { Some(self.table.get(11)?.deref_unchecked()) }
    }

    pub fn node_properties_2(
        &self,
    ) -> Option<&::fidl_next::WireVector<'de, crate::WireNodePropertyEntry2<'de>>> {
        unsafe { Some(self.table.get(12)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireDriverStartArgs<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("DriverStartArgs")
            .field("node", &self.node())
            .field("symbols", &self.symbols())
            .field("url", &self.url())
            .field("program", &self.program())
            .field("incoming", &self.incoming())
            .field("outgoing_dir", &self.outgoing_dir())
            .field("config", &self.config())
            .field("node_name", &self.node_name())
            .field("node_properties", &self.node_properties())
            .field("node_offers", &self.node_offers())
            .field("node_token", &self.node_token())
            .field("node_properties_2", &self.node_properties_2())
            .finish()
    }
}

#[derive(Debug)]
pub struct DriverStartRequest {
    pub start_args: crate::DriverStartArgs,
}

impl ::fidl_next::Encodable for DriverStartRequest {
    type Encoded = WireDriverStartRequest<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for DriverStartRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::Encoder,

    ___E: ::fidl_next::fuchsia::HandleEncoder,
{
    #[inline]
    fn encode(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                start_args,

            } = out;
        }

        ::fidl_next::Encode::encode(self.start_args, encoder, start_args)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for DriverStartRequest {
    type EncodedOption = ::fidl_next::WireBox<'static, WireDriverStartRequest<'static>>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DriverStartRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    DriverStartRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl<'de> ::fidl_next::FromWire<WireDriverStartRequest<'de>> for DriverStartRequest {
    #[inline]
    fn from_wire(wire: WireDriverStartRequest<'de>) -> Self {
        Self { start_args: ::fidl_next::FromWire::from_wire(wire.start_args) }
    }
}

/// The wire type corresponding to [`DriverStartRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireDriverStartRequest<'de> {
    pub start_args: crate::WireDriverStartArgs<'de>,
}

unsafe impl ::fidl_next::Wire for WireDriverStartRequest<'static> {
    type Decoded<'de> = WireDriverStartRequest<'de>;

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireDriverStartRequest<'static>
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::Decoder,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut start_args,

            } = slot;
        }

        ::fidl_next::Decode::decode(start_args.as_mut(), decoder)?;

        Ok(())
    }
}

/// The type corresponding to the Driver protocol.
#[doc = " This protocol is used by the Driver Framework\'s Driver Host to communicate various messages and\n lifecycle hooks to the driver. The connection for this protocol is established through the\n |DriverRegistration| defined in the `driver_symbols` library.\n\n Once the driver has closed its server end, the Driver Framework will initiate the shutdown\n of all dispatchers belonging to this driver.\n"]
#[derive(Debug)]
pub struct Driver;

pub mod driver {
    pub mod prelude {
        pub use crate::{
            driver, Driver, DriverClientHandler, DriverClientSender, DriverServerHandler,
            DriverServerSender,
        };

        pub use crate::DriverStartRequest;

        pub use crate::DriverStartResponse;
    }

    pub struct Start;

    impl ::fidl_next::Method for Start {
        const ORDINAL: u64 = 2863727161496985794;

        type Protocol = crate::Driver;

        type Request = crate::WireDriverStartRequest<'static>;

        type Response = ::fidl_next::WireFlexibleResult<
            'static,
            crate::WireDriverStartResponse,
            ::fidl_next::WireI32,
        >;
    }

    pub struct Stop;

    impl ::fidl_next::Method for Stop {
        const ORDINAL: u64 = 5446759044519003197;

        type Protocol = crate::Driver;

        type Request = ();

        type Response = ::fidl_next::Never;
    }
}

/// A helper trait for the `Driver` client sender.
pub trait DriverClientSender {
    type Transport: ::fidl_next::Transport;

    #[doc = " Starts the driver with the given |start_args|.\n\n Drivers should finish their initial setup and enumeration before returning from |Start|.\n In particular they should enumerate all currently available nodes by utilizing\n `fuchsia.driver.framework/Node.AddChild` and waiting for all calls to be completed.\n\n The Framework will not consider the driver to be started until this call has returned\n successfully. Therefore a driver will not have |Stop| called on it until after it has\n replied to |Start| successfully.\n\n If a driver returns an error, it will not have |Stop| called on it before the\n Driver Framework initiates shutdown of the driver\'s dispatchers. Therefore it should have\n performed all necessary cleanup before returning an error.\n"]
    fn start<___R>(
        &self,
        request: ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, driver::Start>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireDriverStartRequest<'static>,
        >;

    #[doc = " Stops the driver. To stop, the driver should teardown any resources it set up in or after\n |Start|. This is a one-way FIDL method. When the driver has completed stopping, it should\n close its server end. Asynchronous operations should fully complete before closing\n the server end.\n"]
    fn stop(
        &self,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>;
}

impl<___T> DriverClientSender for ::fidl_next::ClientSender<___T, Driver>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;

    #[doc = " Starts the driver with the given |start_args|.\n\n Drivers should finish their initial setup and enumeration before returning from |Start|.\n In particular they should enumerate all currently available nodes by utilizing\n `fuchsia.driver.framework/Node.AddChild` and waiting for all calls to be completed.\n\n The Framework will not consider the driver to be started until this call has returned\n successfully. Therefore a driver will not have |Stop| called on it until after it has\n replied to |Start| successfully.\n\n If a driver returns an error, it will not have |Stop| called on it before the\n Driver Framework initiates shutdown of the driver\'s dispatchers. Therefore it should have\n performed all necessary cleanup before returning an error.\n"]
    fn start<___R>(
        &self,
        request: ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, driver::Start>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireDriverStartRequest<'static>,
        >,
    {
        self.as_untyped()
            .send_two_way(2863727161496985794, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Stops the driver. To stop, the driver should teardown any resources it set up in or after\n |Start|. This is a one-way FIDL method. When the driver has completed stopping, it should\n close its server end. Asynchronous operations should fully complete before closing\n the server end.\n"]
    fn stop(
        &self,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError> {
        self.as_untyped().send_one_way(5446759044519003197, ())
    }
}

/// A client handler for the Driver protocol.
///
/// See [`Driver`] for more details.
pub trait DriverClientHandler<___T: ::fidl_next::Transport> {
    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ClientSender<___T, Driver>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for Driver
where
    ___T: ::fidl_next::Transport,
    ___H: DriverClientHandler<___T>,

    <driver::Start as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    fn on_event(
        handler: &mut ___H,
        sender: &::fidl_next::ClientSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }
}

/// A helper trait for the `Driver` server sender.
pub trait DriverServerSender {
    type Transport: ::fidl_next::Transport;
}

impl<___T> DriverServerSender for ::fidl_next::ServerSender<___T, Driver>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;
}

/// A server handler for the Driver protocol.
///
/// See [`Driver`] for more details.
pub trait DriverServerHandler<___T: ::fidl_next::Transport> {
    #[doc = " Starts the driver with the given |start_args|.\n\n Drivers should finish their initial setup and enumeration before returning from |Start|.\n In particular they should enumerate all currently available nodes by utilizing\n `fuchsia.driver.framework/Node.AddChild` and waiting for all calls to be completed.\n\n The Framework will not consider the driver to be started until this call has returned\n successfully. Therefore a driver will not have |Stop| called on it until after it has\n replied to |Start| successfully.\n\n If a driver returns an error, it will not have |Stop| called on it before the\n Driver Framework initiates shutdown of the driver\'s dispatchers. Therefore it should have\n performed all necessary cleanup before returning an error.\n"]
    fn start(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Driver>,

        request: ::fidl_next::Request<___T, driver::Start>,

        responder: ::fidl_next::Responder<driver::Start>,
    );

    #[doc = " Stops the driver. To stop, the driver should teardown any resources it set up in or after\n |Start|. This is a one-way FIDL method. When the driver has completed stopping, it should\n close its server end. Asynchronous operations should fully complete before closing\n the server end.\n"]
    fn stop(&mut self, sender: &::fidl_next::ServerSender<___T, Driver>);

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Driver>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for Driver
where
    ___T: ::fidl_next::Transport,
    ___H: DriverServerHandler<___T>,

    <driver::Start as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            5446759044519003197 => {
                handler.stop(sender);
            }

            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }

    fn on_two_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
        responder: ::fidl_next::protocol::Responder,
    ) {
        match ordinal {
            2863727161496985794 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.start(sender, decoded, responder),
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }
}

pub const MAX_RESOURCE_NAME_LENGTH: u8 = 128;

pub type NodeAddChildResponse = ();

/// The wire type corresponding to [`NodeAddChildResponse`].
pub type WireNodeAddChildResponse = ();

#[doc = " Error codes for the Node protocol.\n"]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u32)]
pub enum NodeError {
    Internal = 1,
    NodeRemoved = 2,
    NameMissing = 3,
    NameInvalid = 4,
    NameAlreadyExists = 5,
    OfferSourceNameMissing = 6,
    OfferRefExists = 7,
    SymbolNameMissing = 8,
    SymbolAddressMissing = 9,
    SymbolAlreadyExists = 10,
    UnbindChildrenInProgress = 11,
    UnsupportedArgs = 12,
    UnknownOrdinal_(u32),
}

impl ::fidl_next::Encodable for NodeError {
    type Encoded = WireNodeError;
}
impl ::std::convert::From<u32> for NodeError {
    fn from(value: u32) -> Self {
        match value {
            1 => Self::Internal,
            2 => Self::NodeRemoved,
            3 => Self::NameMissing,
            4 => Self::NameInvalid,
            5 => Self::NameAlreadyExists,
            6 => Self::OfferSourceNameMissing,
            7 => Self::OfferRefExists,
            8 => Self::SymbolNameMissing,
            9 => Self::SymbolAddressMissing,
            10 => Self::SymbolAlreadyExists,
            11 => Self::UnbindChildrenInProgress,
            12 => Self::UnsupportedArgs,

            _ => Self::UnknownOrdinal_(value),
        }
    }
}

unsafe impl<___E> ::fidl_next::Encode<___E> for NodeError
where
    ___E: ?Sized,
{
    #[inline]
    fn encode(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::EncodeRef::encode_ref(&self, encoder, out)
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for NodeError
where
    ___E: ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireNodeError { value } = out);
        let _ = value.write(::fidl_next::WireU32::from(match *self {
            Self::Internal => 1,

            Self::NodeRemoved => 2,

            Self::NameMissing => 3,

            Self::NameInvalid => 4,

            Self::NameAlreadyExists => 5,

            Self::OfferSourceNameMissing => 6,

            Self::OfferRefExists => 7,

            Self::SymbolNameMissing => 8,

            Self::SymbolAddressMissing => 9,

            Self::SymbolAlreadyExists => 10,

            Self::UnbindChildrenInProgress => 11,

            Self::UnsupportedArgs => 12,

            Self::UnknownOrdinal_(value) => value,
        }));

        Ok(())
    }
}

impl ::core::convert::From<WireNodeError> for NodeError {
    fn from(wire: WireNodeError) -> Self {
        match u32::from(wire.value) {
            1 => Self::Internal,

            2 => Self::NodeRemoved,

            3 => Self::NameMissing,

            4 => Self::NameInvalid,

            5 => Self::NameAlreadyExists,

            6 => Self::OfferSourceNameMissing,

            7 => Self::OfferRefExists,

            8 => Self::SymbolNameMissing,

            9 => Self::SymbolAddressMissing,

            10 => Self::SymbolAlreadyExists,

            11 => Self::UnbindChildrenInProgress,

            12 => Self::UnsupportedArgs,

            value => Self::UnknownOrdinal_(value),
        }
    }
}

impl ::fidl_next::FromWire<WireNodeError> for NodeError {
    #[inline]
    fn from_wire(wire: WireNodeError) -> Self {
        Self::from(wire)
    }
}

impl ::fidl_next::FromWireRef<WireNodeError> for NodeError {
    #[inline]
    fn from_wire_ref(wire: &WireNodeError) -> Self {
        Self::from(*wire)
    }
}

/// The wire type corresponding to [`NodeError`].
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(transparent)]
pub struct WireNodeError {
    value: ::fidl_next::WireU32,
}

unsafe impl ::fidl_next::Wire for WireNodeError {
    type Decoded<'de> = Self;

    #[inline]
    fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
        // Wire enums have no padding
    }
}

impl WireNodeError {
    pub const INTERNAL: WireNodeError = WireNodeError { value: ::fidl_next::WireU32(1) };

    pub const NODE_REMOVED: WireNodeError = WireNodeError { value: ::fidl_next::WireU32(2) };

    pub const NAME_MISSING: WireNodeError = WireNodeError { value: ::fidl_next::WireU32(3) };

    pub const NAME_INVALID: WireNodeError = WireNodeError { value: ::fidl_next::WireU32(4) };

    pub const NAME_ALREADY_EXISTS: WireNodeError = WireNodeError { value: ::fidl_next::WireU32(5) };

    pub const OFFER_SOURCE_NAME_MISSING: WireNodeError =
        WireNodeError { value: ::fidl_next::WireU32(6) };

    pub const OFFER_REF_EXISTS: WireNodeError = WireNodeError { value: ::fidl_next::WireU32(7) };

    pub const SYMBOL_NAME_MISSING: WireNodeError = WireNodeError { value: ::fidl_next::WireU32(8) };

    pub const SYMBOL_ADDRESS_MISSING: WireNodeError =
        WireNodeError { value: ::fidl_next::WireU32(9) };

    pub const SYMBOL_ALREADY_EXISTS: WireNodeError =
        WireNodeError { value: ::fidl_next::WireU32(10) };

    pub const UNBIND_CHILDREN_IN_PROGRESS: WireNodeError =
        WireNodeError { value: ::fidl_next::WireU32(11) };

    pub const UNSUPPORTED_ARGS: WireNodeError = WireNodeError { value: ::fidl_next::WireU32(12) };
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireNodeError
where
    ___D: ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        _: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        Ok(())
    }
}

impl ::core::convert::From<NodeError> for WireNodeError {
    fn from(natural: NodeError) -> Self {
        match natural {
            NodeError::Internal => WireNodeError::INTERNAL,

            NodeError::NodeRemoved => WireNodeError::NODE_REMOVED,

            NodeError::NameMissing => WireNodeError::NAME_MISSING,

            NodeError::NameInvalid => WireNodeError::NAME_INVALID,

            NodeError::NameAlreadyExists => WireNodeError::NAME_ALREADY_EXISTS,

            NodeError::OfferSourceNameMissing => WireNodeError::OFFER_SOURCE_NAME_MISSING,

            NodeError::OfferRefExists => WireNodeError::OFFER_REF_EXISTS,

            NodeError::SymbolNameMissing => WireNodeError::SYMBOL_NAME_MISSING,

            NodeError::SymbolAddressMissing => WireNodeError::SYMBOL_ADDRESS_MISSING,

            NodeError::SymbolAlreadyExists => WireNodeError::SYMBOL_ALREADY_EXISTS,

            NodeError::UnbindChildrenInProgress => WireNodeError::UNBIND_CHILDREN_IN_PROGRESS,

            NodeError::UnsupportedArgs => WireNodeError::UNSUPPORTED_ARGS,

            NodeError::UnknownOrdinal_(value) => {
                WireNodeError { value: ::fidl_next::WireU32::from(value) }
            }
        }
    }
}

#[doc = " Arguments for adding a node.\n"]
#[derive(Debug, Default)]
pub struct NodeAddArgs {
    pub name: Option<String>,

    pub symbols: Option<Vec<crate::NodeSymbol>>,

    pub properties: Option<Vec<crate::NodeProperty>>,

    pub devfs_args: Option<crate::DevfsAddArgs>,

    pub offers2: Option<Vec<crate::Offer>>,

    pub bus_info: Option<crate::BusInfo>,

    pub properties2: Option<Vec<crate::NodeProperty2>>,
}

impl NodeAddArgs {
    fn __max_ordinal(&self) -> usize {
        if self.name.is_some() {
            return 1;
        }

        if self.symbols.is_some() {
            return 3;
        }

        if self.properties.is_some() {
            return 4;
        }

        if self.devfs_args.is_some() {
            return 5;
        }

        if self.offers2.is_some() {
            return 6;
        }

        if self.bus_info.is_some() {
            return 7;
        }

        if self.properties2.is_some() {
            return 8;
        }

        0
    }
}

impl ::fidl_next::Encodable for NodeAddArgs {
    type Encoded = WireNodeAddArgs<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for NodeAddArgs
where
    ___E: ::fidl_next::Encoder + ?Sized,

    ___E: ::fidl_next::fuchsia::HandleEncoder,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireNodeAddArgs { table } = out);

        let max_ord = self.__max_ordinal();

        let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
        ::fidl_next::Wire::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                8 => {
                    if let Some(properties2) = self.properties2.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            properties2,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                7 => {
                    if let Some(bus_info) = self.bus_info.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            bus_info,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                6 => {
                    if let Some(offers2) = self.offers2.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            offers2,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                5 => {
                    if let Some(devfs_args) = self.devfs_args.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            devfs_args,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(properties) = self.properties.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            properties,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(symbols) = self.symbols.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            symbols,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(name) = self.name.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

impl<'de> ::fidl_next::FromWire<WireNodeAddArgs<'de>> for NodeAddArgs {
    #[inline]
    fn from_wire(wire: WireNodeAddArgs<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let name = wire.table.get(1);

        let symbols = wire.table.get(3);

        let properties = wire.table.get(4);

        let devfs_args = wire.table.get(5);

        let offers2 = wire.table.get(6);

        let bus_info = wire.table.get(7);

        let properties2 = wire.table.get(8);

        Self {


                name: name.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() }
                )),


                symbols: symbols.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireNodeSymbol<'de>>>() }
                )),


                properties: properties.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireNodeProperty<'de>>>() }
                )),


                devfs_args: devfs_args.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<crate::WireDevfsAddArgs<'de>>() }
                )),


                offers2: offers2.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireOffer<'de>>>() }
                )),


                bus_info: bus_info.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<crate::WireBusInfo<'de>>() }
                )),


                properties2: properties2.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireNodeProperty2<'de>>>() }
                )),

        }
    }
}

/// The wire type corresponding to [`NodeAddArgs`].
#[repr(C)]
pub struct WireNodeAddArgs<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireNodeAddArgs<'de> {
    fn drop(&mut self) {
        let _ = self
            .table
            .get(1)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self.table.get(3).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireNodeSymbol<'de>>>()
        });

        let _ = self.table.get(4).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireNodeProperty<'de>>>()
        });

        let _ = self
            .table
            .get(5)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireDevfsAddArgs<'de>>() });

        let _ = self.table.get(6).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireOffer<'de>>>()
        });

        let _ = self
            .table
            .get(7)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireBusInfo<'de>>() });

        let _ = self.table.get(8).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next::WireVector<'de, crate::WireNodeProperty2<'de>>>()
        });
    }
}

unsafe impl ::fidl_next::Wire for WireNodeAddArgs<'static> {
    type Decoded<'de> = WireNodeAddArgs<'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 WireNodeAddArgs<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let name = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

                    if name.len() > 128 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: name.len() as u64,
                            limit: 128,
                        });
                    }

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::WireVector<'static, crate::WireNodeSymbol<'static>>,
                    >(slot.as_mut(), decoder)?;

                    let symbols = unsafe {
                        slot
                                            .deref_unchecked()
                                            .deref_unchecked::<
                                                ::fidl_next::WireVector<'_, crate::WireNodeSymbol<'_>>
                                            >()
                    };

                    if symbols.len() > 64 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: symbols.len() as u64,
                            limit: 64,
                        });
                    }

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::WireVector<'static, crate::WireNodeProperty<'static>>,
                    >(slot.as_mut(), decoder)?;

                    let properties = unsafe {
                        slot
                                            .deref_unchecked()
                                            .deref_unchecked::<
                                                ::fidl_next::WireVector<'_, crate::WireNodeProperty<'_>>
                                            >()
                    };

                    if properties.len() > 64 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: properties.len() as u64,
                            limit: 64,
                        });
                    }

                    Ok(())
                }

                5 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireDevfsAddArgs<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                6 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::WireVector<'static, crate::WireOffer<'static>>,
                    >(slot.as_mut(), decoder)?;

                    let offers2 = unsafe {
                        slot.deref_unchecked()
                            .deref_unchecked::<::fidl_next::WireVector<'_, crate::WireOffer<'_>>>()
                    };

                    if offers2.len() > 128 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: offers2.len() as u64,
                            limit: 128,
                        });
                    }

                    Ok(())
                }

                7 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireBusInfo<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                8 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::WireVector<'static, crate::WireNodeProperty2<'static>>,
                    >(slot.as_mut(), decoder)?;

                    let properties2 = unsafe {
                        slot
                                            .deref_unchecked()
                                            .deref_unchecked::<
                                                ::fidl_next::WireVector<'_, crate::WireNodeProperty2<'_>>
                                            >()
                    };

                    if properties2.len() > 64 {
                        return Err(::fidl_next::DecodeError::VectorTooLong {
                            size: properties2.len() as u64,
                            limit: 64,
                        });
                    }

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl<'de> WireNodeAddArgs<'de> {
    pub fn name(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn symbols(&self) -> Option<&::fidl_next::WireVector<'de, crate::WireNodeSymbol<'de>>> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }

    pub fn properties(
        &self,
    ) -> Option<&::fidl_next::WireVector<'de, crate::WireNodeProperty<'de>>> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }

    pub fn devfs_args(&self) -> Option<&crate::WireDevfsAddArgs<'de>> {
        unsafe { Some(self.table.get(5)?.deref_unchecked()) }
    }

    pub fn offers2(&self) -> Option<&::fidl_next::WireVector<'de, crate::WireOffer<'de>>> {
        unsafe { Some(self.table.get(6)?.deref_unchecked()) }
    }

    pub fn bus_info(&self) -> Option<&crate::WireBusInfo<'de>> {
        unsafe { Some(self.table.get(7)?.deref_unchecked()) }
    }

    pub fn properties2(
        &self,
    ) -> Option<&::fidl_next::WireVector<'de, crate::WireNodeProperty2<'de>>> {
        unsafe { Some(self.table.get(8)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireNodeAddArgs<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("NodeAddArgs")
            .field("name", &self.name())
            .field("symbols", &self.symbols())
            .field("properties", &self.properties())
            .field("devfs_args", &self.devfs_args())
            .field("offers2", &self.offers2())
            .field("bus_info", &self.bus_info())
            .field("properties2", &self.properties2())
            .finish()
    }
}

#[derive(Debug)]
pub struct NodeAddChildRequest {
    pub args: crate::NodeAddArgs,

    pub controller:
        ::fidl_next::ServerEnd<::fidl_next::fuchsia::zx::Channel, crate::NodeController>,

    pub node: ::fidl_next::ServerEnd<Option<::fidl_next::fuchsia::zx::Channel>, crate::Node>,
}

impl ::fidl_next::Encodable for NodeAddChildRequest {
    type Encoded = WireNodeAddChildRequest<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for NodeAddChildRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,

    ___E: ::fidl_next::Encoder,

    ___E: ::fidl_next::fuchsia::HandleEncoder,
{
    #[inline]
    fn encode(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                args,
                controller,
                node,

            } = out;
        }

        ::fidl_next::Encode::encode(self.args, encoder, args)?;

        ::fidl_next::Encode::encode(self.controller, encoder, controller)?;

        ::fidl_next::Encode::encode(self.node, encoder, node)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for NodeAddChildRequest {
    type EncodedOption = ::fidl_next::WireBox<'static, WireNodeAddChildRequest<'static>>;
}

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for NodeAddChildRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NodeAddChildRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: Option<Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl<'de> ::fidl_next::FromWire<WireNodeAddChildRequest<'de>> for NodeAddChildRequest {
    #[inline]
    fn from_wire(wire: WireNodeAddChildRequest<'de>) -> Self {
        Self {
            args: ::fidl_next::FromWire::from_wire(wire.args),

            controller: ::fidl_next::FromWire::from_wire(wire.controller),

            node: ::fidl_next::FromWire::from_wire(wire.node),
        }
    }
}

/// The wire type corresponding to [`NodeAddChildRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireNodeAddChildRequest<'de> {
    pub args: crate::WireNodeAddArgs<'de>,

    pub controller:
        ::fidl_next::ServerEnd<::fidl_next::fuchsia::WireChannel, crate::NodeController>,

    pub node: ::fidl_next::ServerEnd<::fidl_next::fuchsia::WireOptionalChannel, crate::Node>,
}

unsafe impl ::fidl_next::Wire for WireNodeAddChildRequest<'static> {
    type Decoded<'de> = WireNodeAddChildRequest<'de>;

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireNodeAddChildRequest<'static>
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,

    ___D: ::fidl_next::Decoder,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut args,
                mut controller,
                mut node,

            } = slot;
        }

        ::fidl_next::Decode::decode(args.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(controller.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(node.as_mut(), decoder)?;

        Ok(())
    }
}

/// The type corresponding to the Node protocol.
#[doc = " Protocol through which a driver manages a node that it is bound to.\n Drivers should maintain their client connection to the node. Dropping\n the client connection while the driver is running will cause the\n driver framework to remove the driver and node from the topology.\n If the driver has set `host_restart_on_crash` to \"true\" in their\n component manifest, dropping the connection will initiate a restart of\n the driver host and driver.\n"]
#[derive(Debug)]
pub struct Node;

pub mod node {
    pub mod prelude {
        pub use crate::{
            node, Node, NodeClientHandler, NodeClientSender, NodeServerHandler, NodeServerSender,
        };

        pub use crate::NodeAddChildRequest;

        pub use crate::NodeError;

        pub use crate::NodeAddChildResponse;
    }

    pub struct AddChild;

    impl ::fidl_next::Method for AddChild {
        const ORDINAL: u64 = 8633697350522413353;

        type Protocol = crate::Node;

        type Request = crate::WireNodeAddChildRequest<'static>;

        type Response = ::fidl_next::WireFlexibleResult<
            'static,
            crate::WireNodeAddChildResponse,
            crate::WireNodeError,
        >;
    }
}

/// A helper trait for the `Node` client sender.
pub trait NodeClientSender {
    type Transport: ::fidl_next::Transport;

    #[doc = " Adds a child node to this node.\n\n If `node` is present, this driver takes responsibility for binding to\n the newly created child. Otherwise, the driver framework will locate an\n appropriate driver to bind the child to.\n"]
    fn add_child<___R>(
        &self,
        request: ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, node::AddChild>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeAddChildRequest<'static>,
        >;
}

impl<___T> NodeClientSender for ::fidl_next::ClientSender<___T, Node>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;

    #[doc = " Adds a child node to this node.\n\n If `node` is present, this driver takes responsibility for binding to\n the newly created child. Otherwise, the driver framework will locate an\n appropriate driver to bind the child to.\n"]
    fn add_child<___R>(
        &self,
        request: ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, node::AddChild>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeAddChildRequest<'static>,
        >,
    {
        self.as_untyped()
            .send_two_way(8633697350522413353, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }
}

/// A client handler for the Node protocol.
///
/// See [`Node`] for more details.
pub trait NodeClientHandler<___T: ::fidl_next::Transport> {
    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ClientSender<___T, Node>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for Node
where
    ___T: ::fidl_next::Transport,
    ___H: NodeClientHandler<___T>,

    <node::AddChild as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    fn on_event(
        handler: &mut ___H,
        sender: &::fidl_next::ClientSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }
}

/// A helper trait for the `Node` server sender.
pub trait NodeServerSender {
    type Transport: ::fidl_next::Transport;
}

impl<___T> NodeServerSender for ::fidl_next::ServerSender<___T, Node>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;
}

/// A server handler for the Node protocol.
///
/// See [`Node`] for more details.
pub trait NodeServerHandler<___T: ::fidl_next::Transport> {
    #[doc = " Adds a child node to this node.\n\n If `node` is present, this driver takes responsibility for binding to\n the newly created child. Otherwise, the driver framework will locate an\n appropriate driver to bind the child to.\n"]
    fn add_child(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Node>,

        request: ::fidl_next::Request<___T, node::AddChild>,

        responder: ::fidl_next::Responder<node::AddChild>,
    );

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Node>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for Node
where
    ___T: ::fidl_next::Transport,
    ___H: NodeServerHandler<___T>,

    <node::AddChild as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }

    fn on_two_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
        responder: ::fidl_next::protocol::Responder,
    ) {
        match ordinal {
            8633697350522413353 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.add_child(sender, decoded, responder),
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }
}

#[derive(Clone, Debug, Default)]
pub struct NodeControllerRequestBindRequest {
    pub force_rebind: Option<bool>,

    pub driver_url_suffix: Option<String>,
}

impl NodeControllerRequestBindRequest {
    fn __max_ordinal(&self) -> usize {
        if self.force_rebind.is_some() {
            return 1;
        }

        if self.driver_url_suffix.is_some() {
            return 2;
        }

        0
    }
}

impl ::fidl_next::Encodable for NodeControllerRequestBindRequest {
    type Encoded = WireNodeControllerRequestBindRequest<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for NodeControllerRequestBindRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireNodeControllerRequestBindRequest { table } = out);

        let max_ord = self.__max_ordinal();

        let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
        ::fidl_next::Wire::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                2 => {
                    if let Some(driver_url_suffix) = self.driver_url_suffix.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            driver_url_suffix,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(force_rebind) = self.force_rebind.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            force_rebind,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for NodeControllerRequestBindRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireNodeControllerRequestBindRequest { table } = out);

        let max_ord = self.__max_ordinal();

        let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
        ::fidl_next::Wire::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                2 => {
                    if let Some(driver_url_suffix) = &self.driver_url_suffix {
                        ::fidl_next::WireEnvelope::encode_value(
                            driver_url_suffix,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(force_rebind) = &self.force_rebind {
                        ::fidl_next::WireEnvelope::encode_value(
                            force_rebind,
                            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<WireNodeControllerRequestBindRequest<'de>>
    for NodeControllerRequestBindRequest
{
    #[inline]
    fn from_wire(wire: WireNodeControllerRequestBindRequest<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let force_rebind = wire.table.get(1);

        let driver_url_suffix = wire.table.get(2);

        Self {
            force_rebind: force_rebind.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe { envelope.read_unchecked::<bool>() })
            }),

            driver_url_suffix: driver_url_suffix.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

impl<'de> ::fidl_next::FromWireRef<WireNodeControllerRequestBindRequest<'de>>
    for NodeControllerRequestBindRequest
{
    #[inline]
    fn from_wire_ref(wire: &WireNodeControllerRequestBindRequest<'de>) -> Self {
        Self {
            force_rebind: wire.table.get(1).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<bool>()
                })
            }),

            driver_url_suffix: wire.table.get(2).map(|envelope| {
                ::fidl_next::FromWireRef::from_wire_ref(unsafe {
                    envelope.deref_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),
        }
    }
}

/// The wire type corresponding to [`NodeControllerRequestBindRequest`].
#[repr(C)]
pub struct WireNodeControllerRequestBindRequest<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireNodeControllerRequestBindRequest<'de> {
    fn drop(&mut self) {
        let _ = self.table.get(1).map(|envelope| unsafe { envelope.read_unchecked::<bool>() });

        let _ = self
            .table
            .get(2)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });
    }
}

unsafe impl ::fidl_next::Wire for WireNodeControllerRequestBindRequest<'static> {
    type Decoded<'de> = WireNodeControllerRequestBindRequest<'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 WireNodeControllerRequestBindRequest<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, bool>(slot.as_mut(), decoder)?;

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl<'de> WireNodeControllerRequestBindRequest<'de> {
    pub fn force_rebind(&self) -> Option<&bool> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn driver_url_suffix(&self) -> Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireNodeControllerRequestBindRequest<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("NodeControllerRequestBindRequest")
            .field("force_rebind", &self.force_rebind())
            .field("driver_url_suffix", &self.driver_url_suffix())
            .finish()
    }
}

pub type NodeControllerRequestBindResponse = ();

/// The wire type corresponding to [`NodeControllerRequestBindResponse`].
pub type WireNodeControllerRequestBindResponse = ();

#[derive(Debug, Default)]
pub struct NodeControllerOnBindRequest {
    pub node_token: Option<::fidl_next::fuchsia::zx::Handle>,
}

impl NodeControllerOnBindRequest {
    fn __max_ordinal(&self) -> usize {
        if self.node_token.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for NodeControllerOnBindRequest {
    type Encoded = WireNodeControllerOnBindRequest<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for NodeControllerOnBindRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,

    ___E: ::fidl_next::fuchsia::HandleEncoder,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireNodeControllerOnBindRequest { 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(node_token) = self.node_token.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            node_token,
                            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<WireNodeControllerOnBindRequest<'de>>
    for NodeControllerOnBindRequest
{
    #[inline]
    fn from_wire(wire: WireNodeControllerOnBindRequest<'de>) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);

        let node_token = wire.table.get(1);

        Self {
            node_token: node_token.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::fuchsia::WireHandle>()
                })
            }),
        }
    }
}

/// The wire type corresponding to [`NodeControllerOnBindRequest`].
#[repr(C)]
pub struct WireNodeControllerOnBindRequest<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireNodeControllerOnBindRequest<'de> {
    fn drop(&mut self) {
        let _ = self.table.get(1).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next::fuchsia::WireHandle>()
        });
    }
}

unsafe impl ::fidl_next::Wire for WireNodeControllerOnBindRequest<'static> {
    type Decoded<'de> = WireNodeControllerOnBindRequest<'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 WireNodeControllerOnBindRequest<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::fuchsia::WireHandle>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl<'de> WireNodeControllerOnBindRequest<'de> {
    pub fn node_token(&self) -> Option<&::fidl_next::fuchsia::WireHandle> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireNodeControllerOnBindRequest<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("NodeControllerOnBindRequest")
            .field("node_token", &self.node_token())
            .finish()
    }
}

/// The type corresponding to the NodeController protocol.
#[doc = " Protocol through which a parent node controls one of its children.\n"]
#[derive(Debug)]
pub struct NodeController;

pub mod node_controller {
    pub mod prelude {
        pub use crate::{
            node_controller, NodeController, NodeControllerClientHandler,
            NodeControllerClientSender, NodeControllerServerHandler, NodeControllerServerSender,
        };

        pub use crate::NodeControllerOnBindRequest;

        pub use crate::NodeControllerRequestBindRequest;

        pub use crate::NodeControllerRequestBindResponse;
    }

    pub struct Remove;

    impl ::fidl_next::Method for Remove {
        const ORDINAL: u64 = 6123359741742396225;

        type Protocol = crate::NodeController;

        type Request = ();

        type Response = ::fidl_next::Never;
    }

    pub struct RequestBind;

    impl ::fidl_next::Method for RequestBind {
        const ORDINAL: u64 = 4735909333556220047;

        type Protocol = crate::NodeController;

        type Request = crate::WireNodeControllerRequestBindRequest<'static>;

        type Response = ::fidl_next::WireFlexibleResult<
            'static,
            crate::WireNodeControllerRequestBindResponse,
            ::fidl_next::WireI32,
        >;
    }

    pub struct OnBind;

    impl ::fidl_next::Method for OnBind {
        const ORDINAL: u64 = 5905369594807853098;

        type Protocol = crate::NodeController;

        type Request = ::fidl_next::Never;

        type Response = crate::WireNodeControllerOnBindRequest<'static>;
    }
}

/// A helper trait for the `NodeController` client sender.
pub trait NodeControllerClientSender {
    type Transport: ::fidl_next::Transport;

    #[doc = " Removes the node and all of its children.\n"]
    fn remove(
        &self,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>;

    #[doc = " Request that the framework attempts to bind a driver to this node.\n This is an *additional* request for binding as the framework attempts to bind a node once\n when the node is created.\n * error `ZX_ERR_ALREADY_BOUND` if the node is already bound and `force_rebind` is false.\n * error `ZX_ERR_ALREADY_EXISTS` if the node has an outstanding |RequestBind| call which has\n not completed.\n"]
    fn request_bind<___R>(
        &self,
        request: ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, node_controller::RequestBind>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeControllerRequestBindRequest<'static>,
        >;
}

impl<___T> NodeControllerClientSender for ::fidl_next::ClientSender<___T, NodeController>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;

    #[doc = " Removes the node and all of its children.\n"]
    fn remove(
        &self,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError> {
        self.as_untyped().send_one_way(6123359741742396225, ())
    }

    #[doc = " Request that the framework attempts to bind a driver to this node.\n This is an *additional* request for binding as the framework attempts to bind a node once\n when the node is created.\n * error `ZX_ERR_ALREADY_BOUND` if the node is already bound and `force_rebind` is false.\n * error `ZX_ERR_ALREADY_EXISTS` if the node has an outstanding |RequestBind| call which has\n not completed.\n"]
    fn request_bind<___R>(
        &self,
        request: ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, node_controller::RequestBind>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNodeControllerRequestBindRequest<'static>,
        >,
    {
        self.as_untyped()
            .send_two_way(4735909333556220047, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }
}

/// A client handler for the NodeController protocol.
///
/// See [`NodeController`] for more details.
pub trait NodeControllerClientHandler<___T: ::fidl_next::Transport> {
    #[doc = " Event that is triggered when the associated `Node` is bound to a driver.\n"]
    fn on_bind(
        &mut self,
        sender: &::fidl_next::ClientSender<___T, NodeController>,

        event: ::fidl_next::Response<___T, node_controller::OnBind>,
    );

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ClientSender<___T, NodeController>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for NodeController
where
    ___T: ::fidl_next::Transport,
    ___H: NodeControllerClientHandler<___T>,

    <node_controller::RequestBind as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <node_controller::OnBind as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    fn on_event(
        handler: &mut ___H,
        sender: &::fidl_next::ClientSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            5905369594807853098 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => handler.on_bind(sender, decoded),
                Err(e) => {
                    sender.close();
                }
            },

            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }
}

/// A helper trait for the `NodeController` server sender.
pub trait NodeControllerServerSender {
    type Transport: ::fidl_next::Transport;

    #[doc = " Event that is triggered when the associated `Node` is bound to a driver.\n"]

    fn on_bind<___R>(
        &self,
        request: ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = <node_controller::OnBind as ::fidl_next::Method>::Response,
        >;
}

impl<___T> NodeControllerServerSender for ::fidl_next::ServerSender<___T, NodeController>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;

    #[doc = " Event that is triggered when the associated `Node` is bound to a driver.\n"]

    fn on_bind<___R>(
        &self,
        request: ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = <node_controller::OnBind as ::fidl_next::Method>::Response,
        >,
    {
        self.as_untyped().send_event(5905369594807853098, request)
    }
}

/// A server handler for the NodeController protocol.
///
/// See [`NodeController`] for more details.
pub trait NodeControllerServerHandler<___T: ::fidl_next::Transport> {
    #[doc = " Removes the node and all of its children.\n"]
    fn remove(&mut self, sender: &::fidl_next::ServerSender<___T, NodeController>);

    #[doc = " Request that the framework attempts to bind a driver to this node.\n This is an *additional* request for binding as the framework attempts to bind a node once\n when the node is created.\n * error `ZX_ERR_ALREADY_BOUND` if the node is already bound and `force_rebind` is false.\n * error `ZX_ERR_ALREADY_EXISTS` if the node has an outstanding |RequestBind| call which has\n not completed.\n"]
    fn request_bind(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, NodeController>,

        request: ::fidl_next::Request<___T, node_controller::RequestBind>,

        responder: ::fidl_next::Responder<node_controller::RequestBind>,
    );

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, NodeController>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for NodeController
where
    ___T: ::fidl_next::Transport,
    ___H: NodeControllerServerHandler<___T>,

    <node_controller::RequestBind as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            6123359741742396225 => {
                handler.remove(sender);
            }

            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }

    fn on_two_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
        responder: ::fidl_next::protocol::Responder,
    ) {
        match ordinal {
            4735909333556220047 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.request_bind(sender, decoded, responder),
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }
}

/// Compatibility shims which mimic some API surfaces of the current Rust bindings.
pub mod compat {

    impl ::core::convert::From<crate::Condition> for ::fidl_fuchsia_driver_framework::Condition {
        #[inline]
        fn from(from: crate::Condition) -> Self {
            match crate::Condition::from(from) {
                crate::Condition::Unknown => Self::Unknown,

                crate::Condition::Accept => Self::Accept,

                crate::Condition::Reject => Self::Reject,
            }
        }
    }

    impl ::core::convert::From<crate::BusType> for ::fidl_fuchsia_driver_framework::BusType {
        #[inline]
        fn from(from: crate::BusType) -> Self {
            match crate::BusType::from(from) {
                crate::BusType::Platform => Self::Platform,

                crate::BusType::Acpi => Self::Acpi,

                crate::BusType::DeviceTree => Self::DeviceTree,

                crate::BusType::Pci => Self::Pci,

                crate::BusType::Usb => Self::Usb,

                crate::BusType::Gpio => Self::Gpio,

                crate::BusType::I2C => Self::I2C,

                crate::BusType::Spi => Self::Spi,

                crate::BusType::Sdio => Self::Sdio,

                crate::BusType::Uart => Self::Uart,

                crate::BusType::Spmi => Self::Spmi,

                crate::BusType::UnknownOrdinal_(value) => {
                    Self::__SourceBreaking { unknown_ordinal: value }
                }
            }
        }
    }

    impl ::core::convert::From<crate::DeviceAddressStability>
        for ::fidl_fuchsia_driver_framework::DeviceAddressStability
    {
        #[inline]
        fn from(from: crate::DeviceAddressStability) -> Self {
            match crate::DeviceAddressStability::from(from) {
                crate::DeviceAddressStability::UnstableBetweenDriverRestart => {
                    Self::UnstableBetweenDriverRestart
                }

                crate::DeviceAddressStability::UnstableBetweenBoot => Self::UnstableBetweenBoot,

                crate::DeviceAddressStability::UnstableBetweenSoftwareUpdate => {
                    Self::UnstableBetweenSoftwareUpdate
                }

                crate::DeviceAddressStability::Stable => Self::Stable,

                crate::DeviceAddressStability::UnknownOrdinal_(value) => {
                    Self::__SourceBreaking { unknown_ordinal: value }
                }
            }
        }
    }

    impl ::core::convert::From<crate::DriverPackageType>
        for ::fidl_fuchsia_driver_framework::DriverPackageType
    {
        #[inline]
        fn from(from: crate::DriverPackageType) -> Self {
            match crate::DriverPackageType::from(from) {
                crate::DriverPackageType::Boot => Self::Boot,

                crate::DriverPackageType::Base => Self::Base,

                crate::DriverPackageType::Cached => Self::Cached,

                crate::DriverPackageType::Universe => Self::Universe,

                crate::DriverPackageType::UnknownOrdinal_(value) => {
                    Self::__SourceBreaking { unknown_ordinal: value }
                }
            }
        }
    }

    impl ::core::convert::From<crate::CompositeNodeSpecError>
        for ::fidl_fuchsia_driver_framework::CompositeNodeSpecError
    {
        #[inline]
        fn from(from: crate::CompositeNodeSpecError) -> Self {
            match crate::CompositeNodeSpecError::from(from) {
                crate::CompositeNodeSpecError::MissingArgs => Self::MissingArgs,

                crate::CompositeNodeSpecError::EmptyNodes => Self::EmptyNodes,

                crate::CompositeNodeSpecError::AlreadyExists => Self::AlreadyExists,

                crate::CompositeNodeSpecError::DriverIndexFailure => Self::DriverIndexFailure,

                crate::CompositeNodeSpecError::DuplicateParents => Self::DuplicateParents,

                crate::CompositeNodeSpecError::UnknownOrdinal_(value) => {
                    Self::__SourceBreaking { unknown_ordinal: value }
                }
            }
        }
    }

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client sender over `zx::Channel` for the `CompositeNodeManager`
    /// protocol.
    pub type CompositeNodeManagerProxy =
        ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::CompositeNodeManager>;

    impl ::core::convert::From<crate::CompositeNodeManager>
        for ::fidl_fuchsia_driver_framework::CompositeNodeManagerMarker
    {
        #[inline]
        fn from(_: crate::CompositeNodeManager) -> Self {
            Self
        }
    }

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client sender over `zx::Channel` for the `Driver`
    /// protocol.
    pub type DriverProxy =
        ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::Driver>;

    #[cfg(feature = "driver")]
    impl ::core::convert::From<crate::Driver> for ::fidl_fuchsia_driver_framework::DriverMarker {
        #[inline]
        fn from(_: crate::Driver) -> Self {
            Self
        }
    }

    impl ::core::convert::From<crate::NodeError> for ::fidl_fuchsia_driver_framework::NodeError {
        #[inline]
        fn from(from: crate::NodeError) -> Self {
            match crate::NodeError::from(from) {
                crate::NodeError::Internal => Self::Internal,

                crate::NodeError::NodeRemoved => Self::NodeRemoved,

                crate::NodeError::NameMissing => Self::NameMissing,

                crate::NodeError::NameInvalid => Self::NameInvalid,

                crate::NodeError::NameAlreadyExists => Self::NameAlreadyExists,

                crate::NodeError::OfferSourceNameMissing => Self::OfferSourceNameMissing,

                crate::NodeError::OfferRefExists => Self::OfferRefExists,

                crate::NodeError::SymbolNameMissing => Self::SymbolNameMissing,

                crate::NodeError::SymbolAddressMissing => Self::SymbolAddressMissing,

                crate::NodeError::SymbolAlreadyExists => Self::SymbolAlreadyExists,

                crate::NodeError::UnbindChildrenInProgress => Self::UnbindChildrenInProgress,

                crate::NodeError::UnsupportedArgs => Self::UnsupportedArgs,

                crate::NodeError::UnknownOrdinal_(value) => {
                    Self::__SourceBreaking { unknown_ordinal: value }
                }
            }
        }
    }

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client sender over `zx::Channel` for the `Node`
    /// protocol.
    pub type NodeProxy = ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::Node>;

    impl ::core::convert::From<crate::Node> for ::fidl_fuchsia_driver_framework::NodeMarker {
        #[inline]
        fn from(_: crate::Node) -> Self {
            Self
        }
    }

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client sender over `zx::Channel` for the `NodeController`
    /// protocol.
    pub type NodeControllerProxy =
        ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::NodeController>;

    impl ::core::convert::From<crate::NodeController>
        for ::fidl_fuchsia_driver_framework::NodeControllerMarker
    {
        #[inline]
        fn from(_: crate::NodeController) -> Self {
            Self
        }
    }
}