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

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

    StringValue(String),
}

impl ::fidl_next::Encodable for NodePropertyKey {
    type Encoded = WireNodePropertyKey;
}

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

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

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

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

        Ok(())
    }
}

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

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

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

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

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

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

pub mod node_property_key {
    pub enum Ref<'union> {
        IntValue(&'union ::fidl_next::WireU32),

        StringValue(&'union ::fidl_next::WireString),
    }
}

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

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

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

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

        Ok(())
    }
}

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

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

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

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

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

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

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

        Ok(())
    }
}

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

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

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

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

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

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

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

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

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

        Ok(())
    }
}

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

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

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

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

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

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

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

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

pub mod node_property_value {
    pub enum Ref<'union> {
        IntValue(&'union ::fidl_next::WireU32),

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

        BoolValue(&'union bool),

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

        UnknownOrdinal_(u64),
    }
}

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

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

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

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

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

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

        Ok(())
    }
}

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

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

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

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

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

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

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

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

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

        Ok(())
    }
}

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

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

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

            } = out;
        }

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

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireBindRule> for BindRule {
    #[inline]
    fn take_from(from: &WireBindRule) -> Self {
        Self {
            key: ::fidl_next::TakeFrom::take_from(&from.key),

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

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

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

    pub condition: crate::WireCondition,

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

unsafe impl ::fidl_next::ZeroPadding for WireBindRule {
    #[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
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(())
    }
}

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

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

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

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

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

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

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

        Ok(())
    }
}

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

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

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

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

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

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

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

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

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

pub mod device_address {
    pub enum Ref<'union> {
        IntValue(&'union u8),

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

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

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

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

        UnknownOrdinal_(u64),
    }
}

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

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

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

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

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

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

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

        Ok(())
    }
}

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

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

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

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

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

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

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

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

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

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

        Ok(())
    }
}

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

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

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

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

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

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

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

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

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

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

    pub fn address(&self) -> Option<&crate::WireDeviceAddress> {
        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 ::core::fmt::Debug for WireBusInfo {
    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;
}

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

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

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

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

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

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

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

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

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

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

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

                    Ok(())
                }

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

                    Ok(())
                }

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

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

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

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

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

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

        for i in 1..=max_ord {
            match i {
                9 => {
                    if let Some(is_disabled) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireDriverInfo> for DriverInfo {
    #[inline]
    fn take_from(from: &WireDriverInfo) -> Self {
        Self {
            url: from.url().map(::fidl_next::TakeFrom::take_from),

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

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

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

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

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

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

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

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

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

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

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

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

                    let 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>(
                        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<crate::WireDeviceCategory>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

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

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

    pub fn bind_rules_bytecode(&self) -> Option<&::fidl_next::WireVector<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 ::core::fmt::Debug for WireDriverInfo {
    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)]
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;
}

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

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

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

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

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

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

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

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

                    Ok(())
                }

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

                    Ok(())
                }

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

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

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

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

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

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

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

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

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

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

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

                    Ok(())
                }

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

    pub fn parent_names(&self) -> Option<&::fidl_next::WireVector<::fidl_next::WireString>> {
        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 ::core::fmt::Debug for WireCompositeDriverMatch {
    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;
}

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

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

            } = out;
        }

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireNodeProperty> for NodeProperty {
    #[inline]
    fn take_from(from: &WireNodeProperty) -> Self {
        Self {
            key: ::fidl_next::TakeFrom::take_from(&from.key),

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

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

    pub value: crate::WireNodePropertyValue,
}

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

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

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

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

            } = out;
        }

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireParentSpec> for ParentSpec {
    #[inline]
    fn take_from(from: &WireParentSpec) -> Self {
        Self {
            bind_rules: ::fidl_next::TakeFrom::take_from(&from.bind_rules),

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

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

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

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireParentSpec
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)]
pub struct CompositeNodeSpec {
    pub name: Option<String>,

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for CompositeNodeSpec {
    type Encoded = WireCompositeNodeSpec;
}

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

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

        for i in 1..=max_ord {
            match i {
                2 => {
                    if let Some(parents) = &mut 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) = &mut self.name {
                        ::fidl_next::WireEnvelope::encode_value(
                            name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

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

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

        Ok(())
    }
}

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

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

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

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

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

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

                    Ok(())
                }

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

                    Ok(())
                }

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

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

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

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

#[doc = " Information for a composite that is defined by a composite node spec.\n"]
#[derive(Clone, Debug)]
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;
}

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

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

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

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

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

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

                    Ok(())
                }

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

                    Ok(())
                }

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

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

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

impl ::core::fmt::Debug for WireCompositeInfo {
    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,
    UnknownOrdinal_(u32),
}

impl ::fidl_next::Encodable for CompositeNodeSpecError {
    type Encoded = WireCompositeNodeSpecError;
}

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

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

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

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

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

        type Response = ::fidl_next::WireFlexibleResult<
            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: &mut ___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,
        >;
}

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: &mut ___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,
        >,
    {
        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::RequestBuffer<___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>,

    crate::WireCompositeNodeSpec: ::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);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.add_spec(sender, buffer, responder);
            }

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

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

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

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

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

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

unsafe impl ::fidl_next::ZeroPadding for WireCompositeParent {
    #[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
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>(
                        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 WireCompositeParent {
    pub fn composite(&self) -> Option<&crate::WireCompositeInfo> {
        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 ::core::fmt::Debug for WireCompositeParent {
    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)]
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;
}

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

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

        for i in 1..=max_ord {
            match i {
                5 => {
                    if let Some(controller_connector) = &mut self.controller_connector {
                        ::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) = &mut self.connector_supports {
                        ::fidl_next::WireEnvelope::encode_value(
                            connector_supports,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

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

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

                1 => {
                    if let Some(connector) = &mut self.connector {
                        ::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 ::fidl_next::TakeFrom<WireDevfsAddArgs> for DevfsAddArgs {
    #[inline]
    fn take_from(from: &WireDevfsAddArgs) -> Self {
        Self {
            connector: from.connector().map(::fidl_next::TakeFrom::take_from),

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

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

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

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

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

unsafe impl ::fidl_next::ZeroPadding for WireDevfsAddArgs {
    #[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
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>(
                        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 WireDevfsAddArgs {
    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> {
        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 ::core::fmt::Debug for WireDevfsAddArgs {
    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 = ::fidl_next::WireString;

pub type NodePropertyVector = Vec<crate::NodeProperty>;

/// The wire type corresponding to [`NodePropertyVector`].
pub type WireNodePropertyVector = ::fidl_next::WireVector<crate::WireNodeProperty>;

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

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

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

            } = out;
        }

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<NodePropertyEntry> {
    type EncodedOption = ::fidl_next::WireBox<WireNodePropertyEntry>;
}

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

        Ok(())
    }
}

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

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

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

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

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireNodePropertyEntry
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 = ::fidl_next::WireVector<crate::WireNodePropertyEntry>;

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

    pub value: crate::NodePropertyValue,
}

impl ::fidl_next::Encodable for NodeProperty2 {
    type Encoded = WireNodeProperty2;
}

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

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

            } = out;
        }

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireNodeProperty2> for NodeProperty2 {
    #[inline]
    fn take_from(from: &WireNodeProperty2) -> Self {
        Self {
            key: ::fidl_next::TakeFrom::take_from(&from.key),

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

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

    pub value: crate::WireNodePropertyValue,
}

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

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

pub type NodeProperties = Vec<crate::NodeProperty2>;

/// The wire type corresponding to [`NodeProperties`].
pub type WireNodeProperties = ::fidl_next::WireVector<crate::WireNodeProperty2>;

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

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

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

            } = out;
        }

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<NodePropertyEntry2> {
    type EncodedOption = ::fidl_next::WireBox<WireNodePropertyEntry2>;
}

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

        Ok(())
    }
}

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

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

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

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

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireNodePropertyEntry2
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 = ::fidl_next::WireVector<crate::WireNodePropertyEntry2>;

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

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

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

        for i in 1..=max_ord {
            match i {
                3 => {
                    if let Some(module_name) = &mut 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) = &mut 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) = &mut self.name {
                        ::fidl_next::WireEnvelope::encode_value(
                            name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

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

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

        Ok(())
    }
}

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

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

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

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

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

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

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

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

                    if name.len() > 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>(
                        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 WireNodeSymbol {
    pub fn name(&self) -> Option<&::fidl_next::WireString> {
        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> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }
}

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

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

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

        match self {
            Self::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 Box<Offer> {
    type EncodedOption = WireOptionalOffer;
}

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

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireOffer> for Offer {
    #[inline]
    fn take_from(from: &WireOffer) -> Self {
        match from.raw.ordinal() {
            1 => Self::ZirconTransport(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<::fidl_next_fuchsia_component_decl::WireOffer>()
            })),

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

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

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

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

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

pub mod offer {
    pub enum Ref<'union> {
        ZirconTransport(&'union ::fidl_next_fuchsia_component_decl::WireOffer),

        DriverTransport(&'union ::fidl_next_fuchsia_component_decl::WireOffer),

        UnknownOrdinal_(u64),
    }
}

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

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

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

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

        Ok(())
    }
}

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

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

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

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

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

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

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

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

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

        Ok(())
    }
}

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

pub type NodeOffersVector = Vec<crate::Offer>;

/// The wire type corresponding to [`NodeOffersVector`].
pub type WireNodeOffersVector = ::fidl_next::WireVector<crate::WireOffer>;

#[doc = " Arguments for starting a driver.\n"]
#[derive(Debug)]
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;
}

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

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

        for i in 1..=max_ord {
            match i {
                12 => {
                    if let Some(node_properties_2) = &mut self.node_properties_2 {
                        ::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) = &mut self.node_token {
                        ::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) = &mut self.node_offers {
                        ::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) = &mut self.node_properties {
                        ::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) = &mut self.node_name {
                        ::fidl_next::WireEnvelope::encode_value(
                            node_name,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

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

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

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

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

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

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

                1 => {
                    if let Some(node) = &mut self.node {
                        ::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 ::fidl_next::TakeFrom<WireDriverStartArgs> for DriverStartArgs {
    #[inline]
    fn take_from(from: &WireDriverStartArgs) -> Self {
        Self {
            node: from.node().map(::fidl_next::TakeFrom::take_from),

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

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

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

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

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

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

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

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

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

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

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

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

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

                    Ok(())
                }

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

                    Ok(())
                }

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

                    Ok(())
                }

                10 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::WireVector<crate::WireOffer>,
                    >(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<crate::WireNodePropertyEntry2>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

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

impl WireDriverStartArgs {
    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<crate::WireNodeSymbol>> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

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

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

    pub fn incoming(
        &self,
    ) -> Option<
        &::fidl_next::WireVector<::fidl_next_fuchsia_component_runner::WireComponentNamespaceEntry>,
    > {
        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> {
        unsafe { Some(self.table.get(8)?.deref_unchecked()) }
    }

    pub fn node_properties(
        &self,
    ) -> Option<&::fidl_next::WireVector<crate::WireNodePropertyEntry>> {
        unsafe { Some(self.table.get(9)?.deref_unchecked()) }
    }

    pub fn node_offers(&self) -> Option<&::fidl_next::WireVector<crate::WireOffer>> {
        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<crate::WireNodePropertyEntry2>> {
        unsafe { Some(self.table.get(12)?.deref_unchecked()) }
    }
}

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

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(
        &mut 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(&mut self.start_args, encoder, start_args)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<DriverStartRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireDriverStartRequest>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireDriverStartRequest> for DriverStartRequest {
    #[inline]
    fn take_from(from: &WireDriverStartRequest) -> Self {
        Self { start_args: ::fidl_next::TakeFrom::take_from(&from.start_args) }
    }
}

/// The wire type corresponding to [`DriverStartRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireDriverStartRequest {
    pub start_args: crate::WireDriverStartArgs,
}

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

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

        type Response =
            ::fidl_next::WireFlexibleResult<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: &mut ___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,
        >;

    #[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: &mut ___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,
        >,
    {
        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, &mut ())
    }
}

/// 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::RequestBuffer<___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>,

    crate::WireDriverStartRequest:
        ::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);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.start(sender, buffer, responder);
            }

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

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

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

    pub offers: Option<Vec<::fidl_next_fuchsia_component_decl::Offer>>,

    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.offers.is_some() {
            return 2;
        }

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

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

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

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

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

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

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

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

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

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

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

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

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

        Ok(())
    }
}

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

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

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

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

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

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

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

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

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

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

                    let offers =
                        unsafe {
                            slot.deref_unchecked().deref_unchecked::<::fidl_next::WireVector<
                                ::fidl_next_fuchsia_component_decl::WireOffer,
                            >>()
                        };

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

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::WireVector<crate::WireNodeSymbol>,
                    >(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<crate::WireNodeProperty>,
                    >(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>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

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

                    Ok(())
                }

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

    pub fn offers(
        &self,
    ) -> Option<&::fidl_next::WireVector<::fidl_next_fuchsia_component_decl::WireOffer>> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

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

    pub fn properties(&self) -> Option<&::fidl_next::WireVector<crate::WireNodeProperty>> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }

    pub fn devfs_args(&self) -> Option<&crate::WireDevfsAddArgs> {
        unsafe { Some(self.table.get(5)?.deref_unchecked()) }
    }

    pub fn offers2(&self) -> Option<&::fidl_next::WireVector<crate::WireOffer>> {
        unsafe { Some(self.table.get(6)?.deref_unchecked()) }
    }

    pub fn bus_info(&self) -> Option<&crate::WireBusInfo> {
        unsafe { Some(self.table.get(7)?.deref_unchecked()) }
    }

    pub fn properties2(&self) -> Option<&::fidl_next::WireVector<crate::WireNodeProperty2>> {
        unsafe { Some(self.table.get(8)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireNodeAddArgs {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("NodeAddArgs")
            .field("name", &self.name())
            .field("offers", &self.offers())
            .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;
}

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(
        &mut 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(&mut self.args, encoder, args)?;

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<NodeAddChildRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireNodeAddChildRequest>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireNodeAddChildRequest> for NodeAddChildRequest {
    #[inline]
    fn take_from(from: &WireNodeAddChildRequest) -> Self {
        Self {
            args: ::fidl_next::TakeFrom::take_from(&from.args),

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

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

/// The wire type corresponding to [`NodeAddChildRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireNodeAddChildRequest {
    pub args: crate::WireNodeAddArgs,

    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::ZeroPadding for WireNodeAddChildRequest {
    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

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

        type Response =
            ::fidl_next::WireFlexibleResult<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: &mut ___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,
        >;
}

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: &mut ___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,
        >,
    {
        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::RequestBuffer<___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>,

    crate::WireNodeAddChildRequest:
        ::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);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.add_child(sender, buffer, responder);
            }

            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }
}

#[derive(Clone, Debug)]
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;
}

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

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

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

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

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

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

                    Ok(())
                }

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

impl WireNodeControllerRequestBindRequest {
    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> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }
}

impl ::core::fmt::Debug for WireNodeControllerRequestBindRequest {
    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 = ();

/// 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::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;

        type Response = ::fidl_next::WireFlexibleResult<
            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 = ();
    }
}

/// 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: &mut ___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,
        >;
}

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, &mut ())
    }

    #[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: &mut ___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,
        >,
    {
        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>);

    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>,
{
    fn on_event(
        handler: &mut ___H,
        sender: &::fidl_next::ClientSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            5905369594807853098 => {
                handler.on_bind(sender);
            }

            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(
        &self,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>;
}

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(
        &self,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError> {
        self.as_untyped().send_event(5905369594807853098, &mut ())
    }
}

/// 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::RequestBuffer<___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>,

    crate::WireNodeControllerRequestBindRequest:
        ::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);

                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.request_bind(sender, buffer, responder);
            }

            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }
}

/// Compatibility shims which mimic some API surfaces of the current Rust bindings.
pub mod compat {

    impl ::fidl_next::TakeFrom<crate::WireNodePropertyKey>
        for ::fidl_fuchsia_driver_framework::NodePropertyKey
    {
        #[inline]
        fn take_from(from: &crate::WireNodePropertyKey) -> Self {
            match from.as_ref() {
                crate::node_property_key::Ref::IntValue(value) => {
                    Self::IntValue(::fidl_next::TakeFrom::take_from(value))
                }

                crate::node_property_key::Ref::StringValue(value) => {
                    Self::StringValue(::fidl_next::TakeFrom::take_from(value))
                }
            }
        }
    }

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

    impl ::fidl_next::TakeFrom<crate::WireCondition> for ::fidl_fuchsia_driver_framework::Condition {
        #[inline]
        fn take_from(from: &crate::WireCondition) -> Self {
            match crate::Condition::from(*from) {
                crate::Condition::Unknown => Self::Unknown,

                crate::Condition::Accept => Self::Accept,

                crate::Condition::Reject => Self::Reject,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireNodePropertyValue>
        for ::fidl_fuchsia_driver_framework::NodePropertyValue
    {
        #[inline]
        fn take_from(from: &crate::WireNodePropertyValue) -> Self {
            match from.as_ref() {
                crate::node_property_value::Ref::IntValue(value) => {
                    Self::IntValue(::fidl_next::TakeFrom::take_from(value))
                }

                crate::node_property_value::Ref::StringValue(value) => {
                    Self::StringValue(::fidl_next::TakeFrom::take_from(value))
                }

                crate::node_property_value::Ref::BoolValue(value) => {
                    Self::BoolValue(::fidl_next::TakeFrom::take_from(value))
                }

                crate::node_property_value::Ref::EnumValue(value) => {
                    Self::EnumValue(::fidl_next::TakeFrom::take_from(value))
                }

                crate::node_property_value::Ref::UnknownOrdinal_(unknown_ordinal) => {
                    Self::__SourceBreaking { unknown_ordinal }
                }
            }
        }
    }

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

    impl ::fidl_next::TakeFrom<crate::WireBindRule> for ::fidl_fuchsia_driver_framework::BindRule {
        #[inline]
        fn take_from(from: &crate::WireBindRule) -> Self {
            Self {
                key: ::fidl_next::TakeFrom::take_from(&from.key),

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

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

    impl ::fidl_next::TakeFrom<crate::WireBusType> for ::fidl_fuchsia_driver_framework::BusType {
        #[inline]
        fn take_from(from: &crate::WireBusType) -> 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 ::fidl_next::TakeFrom<crate::WireDeviceAddress>
        for ::fidl_fuchsia_driver_framework::DeviceAddress
    {
        #[inline]
        fn take_from(from: &crate::WireDeviceAddress) -> Self {
            match from.as_ref() {
                crate::device_address::Ref::IntValue(value) => {
                    Self::IntValue(::fidl_next::TakeFrom::take_from(value))
                }

                crate::device_address::Ref::ArrayIntValue(value) => {
                    Self::ArrayIntValue(::fidl_next::TakeFrom::take_from(value))
                }

                crate::device_address::Ref::CharIntValue(value) => {
                    Self::CharIntValue(::fidl_next::TakeFrom::take_from(value))
                }

                crate::device_address::Ref::ArrayCharIntValue(value) => {
                    Self::ArrayCharIntValue(::fidl_next::TakeFrom::take_from(value))
                }

                crate::device_address::Ref::StringValue(value) => {
                    Self::StringValue(::fidl_next::TakeFrom::take_from(value))
                }

                crate::device_address::Ref::UnknownOrdinal_(unknown_ordinal) => {
                    Self::__SourceBreaking { unknown_ordinal }
                }
            }
        }
    }

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

    impl ::fidl_next::TakeFrom<crate::WireDeviceAddressStability>
        for ::fidl_fuchsia_driver_framework::DeviceAddressStability
    {
        #[inline]
        fn take_from(from: &crate::WireDeviceAddressStability) -> 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 ::fidl_next::TakeFrom<crate::WireBusInfo> for ::fidl_fuchsia_driver_framework::BusInfo {
        #[inline]
        fn take_from(from: &crate::WireBusInfo) -> Self {
            Self {
                bus: from.bus().map(::fidl_next::TakeFrom::take_from),

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

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

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireDriverPackageType>
        for ::fidl_fuchsia_driver_framework::DriverPackageType
    {
        #[inline]
        fn take_from(from: &crate::WireDriverPackageType) -> 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 ::fidl_next::TakeFrom<crate::WireDeviceCategory>
        for ::fidl_fuchsia_driver_framework::DeviceCategory
    {
        #[inline]
        fn take_from(from: &crate::WireDeviceCategory) -> Self {
            Self {
                category: from.category().map(::fidl_next::TakeFrom::take_from),

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

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireDriverInfo> for ::fidl_fuchsia_driver_framework::DriverInfo {
        #[inline]
        fn take_from(from: &crate::WireDriverInfo) -> Self {
            Self {
                url: from.url().map(::fidl_next::TakeFrom::take_from),

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

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

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

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

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

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

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

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

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireCompositeDriverInfo>
        for ::fidl_fuchsia_driver_framework::CompositeDriverInfo
    {
        #[inline]
        fn take_from(from: &crate::WireCompositeDriverInfo) -> Self {
            Self {
                composite_name: from.composite_name().map(::fidl_next::TakeFrom::take_from),

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

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireCompositeDriverMatch>
        for ::fidl_fuchsia_driver_framework::CompositeDriverMatch
    {
        #[inline]
        fn take_from(from: &crate::WireCompositeDriverMatch) -> Self {
            Self {
                composite_driver: from.composite_driver().map(::fidl_next::TakeFrom::take_from),

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

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

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireNodeProperty>
        for ::fidl_fuchsia_driver_framework::NodeProperty
    {
        #[inline]
        fn take_from(from: &crate::WireNodeProperty) -> Self {
            Self {
                key: ::fidl_next::TakeFrom::take_from(&from.key),

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

    impl ::fidl_next::TakeFrom<crate::WireParentSpec> for ::fidl_fuchsia_driver_framework::ParentSpec {
        #[inline]
        fn take_from(from: &crate::WireParentSpec) -> Self {
            Self {
                bind_rules: ::fidl_next::TakeFrom::take_from(&from.bind_rules),

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

    impl ::fidl_next::TakeFrom<crate::WireCompositeNodeSpec>
        for ::fidl_fuchsia_driver_framework::CompositeNodeSpec
    {
        #[inline]
        fn take_from(from: &crate::WireCompositeNodeSpec) -> Self {
            Self {
                name: from.name().map(::fidl_next::TakeFrom::take_from),

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

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireCompositeInfo>
        for ::fidl_fuchsia_driver_framework::CompositeInfo
    {
        #[inline]
        fn take_from(from: &crate::WireCompositeInfo) -> Self {
            Self {
                spec: from.spec().map(::fidl_next::TakeFrom::take_from),

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

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireCompositeNodeSpecError>
        for ::fidl_fuchsia_driver_framework::CompositeNodeSpecError
    {
        #[inline]
        fn take_from(from: &crate::WireCompositeNodeSpecError) -> 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::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 ::fidl_next::TakeFrom<crate::CompositeNodeManager>
        for ::fidl_fuchsia_driver_framework::CompositeNodeManagerMarker
    {
        #[inline]
        fn take_from(from: &crate::CompositeNodeManager) -> Self {
            Self
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireCompositeParent>
        for ::fidl_fuchsia_driver_framework::CompositeParent
    {
        #[inline]
        fn take_from(from: &crate::WireCompositeParent) -> Self {
            Self {
                composite: from.composite().map(::fidl_next::TakeFrom::take_from),

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

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireDevfsAddArgs>
        for ::fidl_fuchsia_driver_framework::DevfsAddArgs
    {
        #[inline]
        fn take_from(from: &crate::WireDevfsAddArgs) -> Self {
            Self {
                connector: from.connector().map(::fidl_next::TakeFrom::take_from),

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

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

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

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

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireNodePropertyEntry>
        for ::fidl_fuchsia_driver_framework::NodePropertyEntry
    {
        #[inline]
        fn take_from(from: &crate::WireNodePropertyEntry) -> Self {
            Self {
                name: ::fidl_next::TakeFrom::take_from(&from.name),

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

    impl ::fidl_next::TakeFrom<crate::WireNodeProperty2>
        for ::fidl_fuchsia_driver_framework::NodeProperty2
    {
        #[inline]
        fn take_from(from: &crate::WireNodeProperty2) -> Self {
            Self {
                key: ::fidl_next::TakeFrom::take_from(&from.key),

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

    impl ::fidl_next::TakeFrom<crate::WireNodePropertyEntry2>
        for ::fidl_fuchsia_driver_framework::NodePropertyEntry2
    {
        #[inline]
        fn take_from(from: &crate::WireNodePropertyEntry2) -> Self {
            Self {
                name: ::fidl_next::TakeFrom::take_from(&from.name),

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

    impl ::fidl_next::TakeFrom<crate::WireNodeSymbol> for ::fidl_fuchsia_driver_framework::NodeSymbol {
        #[inline]
        fn take_from(from: &crate::WireNodeSymbol) -> Self {
            Self {
                name: from.name().map(::fidl_next::TakeFrom::take_from),

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

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

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireOffer> for ::fidl_fuchsia_driver_framework::Offer {
        #[inline]
        fn take_from(from: &crate::WireOffer) -> Self {
            match from.as_ref() {
                crate::offer::Ref::ZirconTransport(value) => {
                    Self::ZirconTransport(::fidl_next::TakeFrom::take_from(value))
                }

                crate::offer::Ref::DriverTransport(value) => {
                    Self::DriverTransport(::fidl_next::TakeFrom::take_from(value))
                }

                crate::offer::Ref::UnknownOrdinal_(unknown_ordinal) => {
                    Self::__SourceBreaking { unknown_ordinal }
                }
            }
        }
    }

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

    impl ::fidl_next::TakeFrom<crate::WireDriverStartArgs>
        for ::fidl_fuchsia_driver_framework::DriverStartArgs
    {
        #[inline]
        fn take_from(from: &crate::WireDriverStartArgs) -> Self {
            Self {
                node: from.node().map(::fidl_next::TakeFrom::take_from),

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

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

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

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

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

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

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

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

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

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

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

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    #[cfg(feature = "driver")]
    impl ::fidl_next::TakeFrom<crate::WireDriverStartRequest>
        for ::fidl_fuchsia_driver_framework::DriverStartRequest
    {
        #[inline]
        fn take_from(from: &crate::WireDriverStartRequest) -> Self {
            Self { start_args: ::fidl_next::TakeFrom::take_from(&from.start_args) }
        }
    }

    #[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 ::fidl_next::TakeFrom<crate::Driver> for ::fidl_fuchsia_driver_framework::DriverMarker {
        #[inline]
        fn take_from(from: &crate::Driver) -> Self {
            Self
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireNodeError> for ::fidl_fuchsia_driver_framework::NodeError {
        #[inline]
        fn take_from(from: &crate::WireNodeError) -> 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 }
                }
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireNodeAddArgs>
        for ::fidl_fuchsia_driver_framework::NodeAddArgs
    {
        #[inline]
        fn take_from(from: &crate::WireNodeAddArgs) -> Self {
            Self {
                name: from.name().map(::fidl_next::TakeFrom::take_from),

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

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

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

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

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

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

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

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireNodeAddChildRequest>
        for ::fidl_fuchsia_driver_framework::NodeAddChildRequest
    {
        #[inline]
        fn take_from(from: &crate::WireNodeAddChildRequest) -> Self {
            Self {
                args: ::fidl_next::TakeFrom::take_from(&from.args),

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

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

    #[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 ::fidl_next::TakeFrom<crate::Node> for ::fidl_fuchsia_driver_framework::NodeMarker {
        #[inline]
        fn take_from(from: &crate::Node) -> Self {
            Self
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireNodeControllerRequestBindRequest>
        for ::fidl_fuchsia_driver_framework::NodeControllerRequestBindRequest
    {
        #[inline]
        fn take_from(from: &crate::WireNodeControllerRequestBindRequest) -> Self {
            Self {
                force_rebind: from.force_rebind().map(::fidl_next::TakeFrom::take_from),

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

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    #[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 ::fidl_next::TakeFrom<crate::NodeController>
        for ::fidl_fuchsia_driver_framework::NodeControllerMarker
    {
        #[inline]
        fn take_from(from: &crate::NodeController) -> Self {
            Self
        }
    }
}