fidl_next_fuchsia_component/

fidl_next_fuchsia_component.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)]

/// The type corresponding to the Binder protocol.
#[doc = " A framework-provided protocol that allows components that use it to bind to\n the component that exposes it. The act of connecting to this protocol will\n trigger the bind. Thus, this protocol contains no methods. For more details\n on binding, see\n https://fuchsia.dev/fuchsia-src/concepts/components/v2/lifecycle#binding.\n\n When a component connects to protocol, the component exposing this capability\n will be started if it\'s not already running. Upon a failure to start, the\n component framework will close the server end of the channel with a\n zx.Status epitaph.\n"]
#[derive(Debug)]
pub struct Binder;

impl ::fidl_next::Discoverable for Binder {
    const PROTOCOL_NAME: &'static str = "fuchsia.component.Binder";
}

pub mod binder {
    pub mod prelude {
        pub use crate::{
            binder, Binder, BinderClientHandler, BinderClientSender, BinderServerHandler,
            BinderServerSender,
        };
    }
}

/// A helper trait for the `Binder` client sender.
pub trait BinderClientSender {
    type Transport: ::fidl_next::Transport;
}

impl<___T> BinderClientSender for ::fidl_next::ClientSender<___T, Binder>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;
}

/// A client handler for the Binder protocol.
///
/// See [`Binder`] for more details.
pub trait BinderClientHandler<___T: ::fidl_next::Transport> {}

impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for Binder
where
    ___T: ::fidl_next::Transport,
    ___H: BinderClientHandler<___T>,
{
    fn on_event(
        handler: &mut ___H,
        sender: &::fidl_next::ClientSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => {
                sender.close();
            }
        }
    }
}

/// A helper trait for the `Binder` server sender.
pub trait BinderServerSender {
    type Transport: ::fidl_next::Transport;
}

impl<___T> BinderServerSender for ::fidl_next::ServerSender<___T, Binder>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;
}

/// A server handler for the Binder protocol.
///
/// See [`Binder`] for more details.
pub trait BinderServerHandler<___T: ::fidl_next::Transport> {}

impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for Binder
where
    ___T: ::fidl_next::Transport,
    ___H: BinderServerHandler<___T>,
{
    fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => {
                sender.close();
            }
        }
    }

    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 {
            ordinal => {
                sender.close();
            }
        }
    }
}

pub const MAX_NAME_LENGTH: u64 = 255;

pub type Name = String;

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

#[doc = " Payload for CapabilityRequested events\n"]
#[derive(Debug, Default)]
pub struct CapabilityRequestedPayload {
    pub name: Option<String>,

    pub capability: Option<::fidl_next::fuchsia::zx::Handle>,
}

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

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

        0
    }
}

impl ::fidl_next::Encodable for CapabilityRequestedPayload {
    type Encoded = WireCapabilityRequestedPayload<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityRequestedPayload
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 WireCapabilityRequestedPayload { table } = out);

        let max_ord = self.__max_ordinal();

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

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

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

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

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

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

        Ok(())
    }
}

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

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

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

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

            capability: capability.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::fuchsia::WireHandle>()
                })
            }),
        }
    }
}

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

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

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

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

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { table } = out);
        ::fidl_next::WireTable::zero_padding(table);
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityRequestedPayload<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

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

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

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

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

                    Ok(())
                }

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

                    Ok(())
                }

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

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

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

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

#[doc = " The maximum number of children that the a call `ChildIterator.Next`\n can return.\n Note, this is not a limit on the number of children that can be added\n to a component. This is merely a limit for a single invocation of the\n `Next` method.\n"]
pub const MAX_CHILD_COUNT: u32 = 128;

#[derive(Clone, Debug)]
pub struct ChildIteratorNextResponse {
    pub children: Vec<::fidl_next_fuchsia_component_decl::ChildRef>,
}

impl ::fidl_next::Encodable for ChildIteratorNextResponse {
    type Encoded = WireChildIteratorNextResponse<'static>;
}

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

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

            } = out;
        }

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

        Ok(())
    }
}

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

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

            } = out;
        }

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

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

        Ok(())
    }
}

impl<'de> ::fidl_next::FromWire<WireChildIteratorNextResponse<'de>> for ChildIteratorNextResponse {
    #[inline]
    fn from_wire(wire: WireChildIteratorNextResponse<'de>) -> Self {
        Self { children: ::fidl_next::FromWire::from_wire(wire.children) }
    }
}

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

/// The wire type corresponding to [`ChildIteratorNextResponse`].
#[derive(Debug)]
#[repr(C)]
pub struct WireChildIteratorNextResponse<'de> {
    pub children:
        ::fidl_next::WireVector<'de, ::fidl_next_fuchsia_component_decl::WireChildRef<'de>>,
}

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

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

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

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

            } = slot;
        }

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

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

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

        Ok(())
    }
}

/// The type corresponding to the ChildIterator protocol.
#[doc = " A protocol to iterate over the list of children in a realm.\n"]
#[derive(Debug)]
pub struct ChildIterator;

pub mod child_iterator {
    pub mod prelude {
        pub use crate::{
            child_iterator, ChildIterator, ChildIteratorClientHandler, ChildIteratorClientSender,
            ChildIteratorServerHandler, ChildIteratorServerSender,
        };

        pub use crate::ChildIteratorNextResponse;
    }

    pub struct Next;

    impl ::fidl_next::Method for Next {
        const ORDINAL: u64 = 4676077302722137352;

        type Protocol = crate::ChildIterator;

        type Request = ();

        type Response = crate::WireChildIteratorNextResponse<'static>;
    }
}

/// A helper trait for the `ChildIterator` client sender.
pub trait ChildIteratorClientSender {
    type Transport: ::fidl_next::Transport;

    #[doc = " Advance the iterator and return the next batch of children.\n\n Returns a vector of `ChildRef`. Returns an empty vector when there are\n no more children.\n"]
    fn next(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, child_iterator::Next>,
        ::fidl_next::EncodeError,
    >;
}

impl<___T> ChildIteratorClientSender for ::fidl_next::ClientSender<___T, ChildIterator>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;

    #[doc = " Advance the iterator and return the next batch of children.\n\n Returns a vector of `ChildRef`. Returns an empty vector when there are\n no more children.\n"]
    fn next(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, child_iterator::Next>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(4676077302722137352, ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }
}

/// A client handler for the ChildIterator protocol.
///
/// See [`ChildIterator`] for more details.
pub trait ChildIteratorClientHandler<___T: ::fidl_next::Transport> {}

impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for ChildIterator
where
    ___T: ::fidl_next::Transport,
    ___H: ChildIteratorClientHandler<___T>,

    <child_iterator::Next 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 => {
                sender.close();
            }
        }
    }
}

/// A helper trait for the `ChildIterator` server sender.
pub trait ChildIteratorServerSender {
    type Transport: ::fidl_next::Transport;
}

impl<___T> ChildIteratorServerSender for ::fidl_next::ServerSender<___T, ChildIterator>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;
}

/// A server handler for the ChildIterator protocol.
///
/// See [`ChildIterator`] for more details.
pub trait ChildIteratorServerHandler<___T: ::fidl_next::Transport> {
    #[doc = " Advance the iterator and return the next batch of children.\n\n Returns a vector of `ChildRef`. Returns an empty vector when there are\n no more children.\n"]
    fn next(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, ChildIterator>,

        responder: ::fidl_next::Responder<child_iterator::Next>,
    );
}

impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for ChildIterator
where
    ___T: ::fidl_next::Transport,
    ___H: ChildIteratorServerHandler<___T>,
{
    fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => {
                sender.close();
            }
        }
    }

    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 {
            4676077302722137352 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.next(sender, responder);
            }

            ordinal => {
                sender.close();
            }
        }
    }
}

#[doc = " The maximum number of handles that can be passed to a created component.\n"]
pub const MAX_HANDLE_COUNT: u32 = 128;

pub const MAX_NAMESPACE_COUNT: u32 = 32;

pub type ControllerStartResponse = ();

/// The wire type corresponding to [`ControllerStartResponse`].
pub type WireControllerStartResponse = ();

#[derive(Debug)]
#[repr(C)]
pub struct ControllerIsStartedResponse {
    pub is_started: bool,
}

impl ::fidl_next::Encodable for ControllerIsStartedResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireControllerIsStartedResponse> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <bool as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    type Encoded = WireControllerIsStartedResponse;
}

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

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

            } = out;
        }

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

impl ::fidl_next::FromWire<WireControllerIsStartedResponse> for ControllerIsStartedResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireControllerIsStartedResponse, Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <bool as ::fidl_next::FromWire<bool>>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    #[inline]
    fn from_wire(wire: WireControllerIsStartedResponse) -> Self {
        Self { is_started: ::fidl_next::FromWire::from_wire(wire.is_started) }
    }
}

/// The wire type corresponding to [`ControllerIsStartedResponse`].
#[derive(Debug)]
#[repr(C)]
pub struct WireControllerIsStartedResponse {
    pub is_started: bool,
}

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

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireControllerIsStartedResponse
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?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 {
                mut is_started,

            } = slot;
        }

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

        Ok(())
    }
}

pub const MAX_PATH_LENGTH: u64 = 4095;

#[doc = " Standard error codes for component framework protocols.\n"]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u32)]
pub enum Error {
    Internal = 1,
    InvalidArguments = 2,
    Unsupported = 3,
    AccessDenied = 4,
    InstanceNotFound = 5,
    InstanceAlreadyExists = 6,
    InstanceCannotStart = 7,
    InstanceCannotResolve = 8,
    CollectionNotFound = 9,
    ResourceUnavailable = 10,
    InstanceDied = 11,
    ResourceNotFound = 12,
    InstanceCannotUnresolve = 13,
    InstanceAlreadyStarted = 14,
    UnknownOrdinal_(u32),
}

impl ::fidl_next::Encodable for Error {
    type Encoded = WireError;
}
impl ::std::convert::From<u32> for Error {
    fn from(value: u32) -> Self {
        match value {
            1 => Self::Internal,
            2 => Self::InvalidArguments,
            3 => Self::Unsupported,
            4 => Self::AccessDenied,
            5 => Self::InstanceNotFound,
            6 => Self::InstanceAlreadyExists,
            7 => Self::InstanceCannotStart,
            8 => Self::InstanceCannotResolve,
            9 => Self::CollectionNotFound,
            10 => Self::ResourceUnavailable,
            11 => Self::InstanceDied,
            12 => Self::ResourceNotFound,
            13 => Self::InstanceCannotUnresolve,
            14 => Self::InstanceAlreadyStarted,

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

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

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

            Self::InvalidArguments => 2,

            Self::Unsupported => 3,

            Self::AccessDenied => 4,

            Self::InstanceNotFound => 5,

            Self::InstanceAlreadyExists => 6,

            Self::InstanceCannotStart => 7,

            Self::InstanceCannotResolve => 8,

            Self::CollectionNotFound => 9,

            Self::ResourceUnavailable => 10,

            Self::InstanceDied => 11,

            Self::ResourceNotFound => 12,

            Self::InstanceCannotUnresolve => 13,

            Self::InstanceAlreadyStarted => 14,

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

        Ok(())
    }
}

impl ::core::convert::From<WireError> for Error {
    fn from(wire: WireError) -> Self {
        match u32::from(wire.value) {
            1 => Self::Internal,

            2 => Self::InvalidArguments,

            3 => Self::Unsupported,

            4 => Self::AccessDenied,

            5 => Self::InstanceNotFound,

            6 => Self::InstanceAlreadyExists,

            7 => Self::InstanceCannotStart,

            8 => Self::InstanceCannotResolve,

            9 => Self::CollectionNotFound,

            10 => Self::ResourceUnavailable,

            11 => Self::InstanceDied,

            12 => Self::ResourceNotFound,

            13 => Self::InstanceCannotUnresolve,

            14 => Self::InstanceAlreadyStarted,

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

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

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

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

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

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

impl WireError {
    pub const INTERNAL: WireError = WireError { value: ::fidl_next::WireU32(1) };

    pub const INVALID_ARGUMENTS: WireError = WireError { value: ::fidl_next::WireU32(2) };

    pub const UNSUPPORTED: WireError = WireError { value: ::fidl_next::WireU32(3) };

    pub const ACCESS_DENIED: WireError = WireError { value: ::fidl_next::WireU32(4) };

    pub const INSTANCE_NOT_FOUND: WireError = WireError { value: ::fidl_next::WireU32(5) };

    pub const INSTANCE_ALREADY_EXISTS: WireError = WireError { value: ::fidl_next::WireU32(6) };

    pub const INSTANCE_CANNOT_START: WireError = WireError { value: ::fidl_next::WireU32(7) };

    pub const INSTANCE_CANNOT_RESOLVE: WireError = WireError { value: ::fidl_next::WireU32(8) };

    pub const COLLECTION_NOT_FOUND: WireError = WireError { value: ::fidl_next::WireU32(9) };

    pub const RESOURCE_UNAVAILABLE: WireError = WireError { value: ::fidl_next::WireU32(10) };

    pub const INSTANCE_DIED: WireError = WireError { value: ::fidl_next::WireU32(11) };

    pub const RESOURCE_NOT_FOUND: WireError = WireError { value: ::fidl_next::WireU32(12) };

    pub const INSTANCE_CANNOT_UNRESOLVE: WireError = WireError { value: ::fidl_next::WireU32(13) };

    pub const INSTANCE_ALREADY_STARTED: WireError = WireError { value: ::fidl_next::WireU32(14) };
}

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

impl ::core::convert::From<Error> for WireError {
    fn from(natural: Error) -> Self {
        match natural {
            Error::Internal => WireError::INTERNAL,

            Error::InvalidArguments => WireError::INVALID_ARGUMENTS,

            Error::Unsupported => WireError::UNSUPPORTED,

            Error::AccessDenied => WireError::ACCESS_DENIED,

            Error::InstanceNotFound => WireError::INSTANCE_NOT_FOUND,

            Error::InstanceAlreadyExists => WireError::INSTANCE_ALREADY_EXISTS,

            Error::InstanceCannotStart => WireError::INSTANCE_CANNOT_START,

            Error::InstanceCannotResolve => WireError::INSTANCE_CANNOT_RESOLVE,

            Error::CollectionNotFound => WireError::COLLECTION_NOT_FOUND,

            Error::ResourceUnavailable => WireError::RESOURCE_UNAVAILABLE,

            Error::InstanceDied => WireError::INSTANCE_DIED,

            Error::ResourceNotFound => WireError::RESOURCE_NOT_FOUND,

            Error::InstanceCannotUnresolve => WireError::INSTANCE_CANNOT_UNRESOLVE,

            Error::InstanceAlreadyStarted => WireError::INSTANCE_ALREADY_STARTED,

            Error::UnknownOrdinal_(value) => WireError { value: ::fidl_next::WireU32::from(value) },
        }
    }
}

#[doc = " A single component namespace entry, which describes a namespace mount point\n (`path`) and the directory backing it (`directory`). This type is usually\n composed inside a vector.  See `ComponentStartInfo.ns` for more details.\n"]
#[derive(Debug, Default)]
pub struct NamespaceEntry {
    pub path: Option<String>,

    pub directory: Option<
        ::fidl_next::ClientEnd<
            ::fidl_next::fuchsia::zx::Channel,
            ::fidl_next_fuchsia_io::Directory,
        >,
    >,
}

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

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

        0
    }
}

impl ::fidl_next::Encodable for NamespaceEntry {
    type Encoded = WireNamespaceEntry<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for NamespaceEntry
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 WireNamespaceEntry { table } = out);

        let max_ord = self.__max_ordinal();

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

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

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

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

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

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

        Ok(())
    }
}

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

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

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

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

            directory: directory.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::ClientEnd<
                        ::fidl_next::fuchsia::WireChannel,
                        ::fidl_next_fuchsia_io::Directory,
                    >>()
                })
            }),
        }
    }
}

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

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

        let _ = self.table.get(2).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next::ClientEnd<
                ::fidl_next::fuchsia::WireChannel,
                ::fidl_next_fuchsia_io::Directory,
            >>()
        });
    }
}

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

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { table } = out);
        ::fidl_next::WireTable::zero_padding(table);
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireNamespaceEntry<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

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

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

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

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

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::ClientEnd<
                            ::fidl_next::fuchsia::WireChannel,
                            ::fidl_next_fuchsia_io::Directory,
                        >,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

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

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

    pub fn directory(
        &self,
    ) -> Option<
        &::fidl_next::ClientEnd<
            ::fidl_next::fuchsia::WireChannel,
            ::fidl_next_fuchsia_io::Directory,
        >,
    > {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireNamespaceEntry<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("NamespaceEntry")
            .field("path", &self.path())
            .field("directory", &self.directory())
            .finish()
    }
}

#[derive(Debug, Default)]
pub struct StartChildArgs {
    pub numbered_handles: Option<Vec<::fidl_next_fuchsia_process::HandleInfo>>,

    pub namespace_entries: Option<Vec<crate::NamespaceEntry>>,

    pub dictionary: Option<::fidl_next_fuchsia_component_sandbox::DictionaryRef>,
}

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for StartChildArgs {
    type Encoded = WireStartChildArgs<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for StartChildArgs
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 WireStartChildArgs { table } = out);

        let max_ord = self.__max_ordinal();

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

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

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

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

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

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

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

        Ok(())
    }
}

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

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

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

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

        Self {


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


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


                dictionary: dictionary.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next_fuchsia_component_sandbox::WireDictionaryRef>() }
                )),

        }
    }
}

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

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

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

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

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

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { table } = out);
        ::fidl_next::WireTable::zero_padding(table);
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireStartChildArgs<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

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

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

                    let numbered_handles = unsafe {
                        slot
                                            .deref_unchecked()
                                            .deref_unchecked::<
                                                ::fidl_next::WireVector<'_, ::fidl_next_fuchsia_process::WireHandleInfo>
                                            >()
                    };

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

                    Ok(())
                }

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

                    let namespace_entries = unsafe {
                        slot
                                            .deref_unchecked()
                                            .deref_unchecked::<
                                                ::fidl_next::WireVector<'_, crate::WireNamespaceEntry<'_>>
                                            >()
                    };

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

                    Ok(())
                }

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

                    Ok(())
                }

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

impl<'de> WireStartChildArgs<'de> {
    pub fn numbered_handles(
        &self,
    ) -> Option<&::fidl_next::WireVector<'de, ::fidl_next_fuchsia_process::WireHandleInfo>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

    pub fn dictionary(&self) -> Option<&::fidl_next_fuchsia_component_sandbox::WireDictionaryRef> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireStartChildArgs<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("StartChildArgs")
            .field("numbered_handles", &self.numbered_handles())
            .field("namespace_entries", &self.namespace_entries())
            .field("dictionary", &self.dictionary())
            .finish()
    }
}

#[derive(Debug)]
pub struct ControllerStartRequest {
    pub args: crate::StartChildArgs,

    pub execution_controller:
        ::fidl_next::ServerEnd<::fidl_next::fuchsia::zx::Channel, crate::ExecutionController>,
}

impl ::fidl_next::Encodable for ControllerStartRequest {
    type Encoded = WireControllerStartRequest<'static>;
}

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

    ___E: ::fidl_next::Encoder,

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

            } = out;
        }

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

impl<'de> ::fidl_next::FromWire<WireControllerStartRequest<'de>> for ControllerStartRequest {
    #[inline]
    fn from_wire(wire: WireControllerStartRequest<'de>) -> Self {
        Self {
            args: ::fidl_next::FromWire::from_wire(wire.args),

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

/// The wire type corresponding to [`ControllerStartRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireControllerStartRequest<'de> {
    pub args: crate::WireStartChildArgs<'de>,

    pub execution_controller:
        ::fidl_next::ServerEnd<::fidl_next::fuchsia::WireChannel, crate::ExecutionController>,
}

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

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

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

    ___D: ::fidl_next::Decoder,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut args,
                mut execution_controller,

            } = slot;
        }

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

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

        Ok(())
    }
}

#[derive(Debug)]
#[repr(C)]
pub struct ControllerGetExposedDictionaryResponse {
    pub dictionary: ::fidl_next_fuchsia_component_sandbox::DictionaryRef,
}

impl ::fidl_next::Encodable for ControllerGetExposedDictionaryResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
        Self,
        WireControllerGetExposedDictionaryResponse,
    > = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true

                && <
                    ::fidl_next_fuchsia_component_sandbox::DictionaryRef as ::fidl_next::Encodable
                >::COPY_OPTIMIZATION.is_enabled()

        )
    };

    type Encoded = WireControllerGetExposedDictionaryResponse;
}

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

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

            } = out;
        }

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

impl ::fidl_next::FromWire<WireControllerGetExposedDictionaryResponse>
    for ControllerGetExposedDictionaryResponse
{
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
        WireControllerGetExposedDictionaryResponse,
        Self,
    > = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true

                && <
                    ::fidl_next_fuchsia_component_sandbox::DictionaryRef as ::fidl_next::FromWire<::fidl_next_fuchsia_component_sandbox::WireDictionaryRef>
                >::COPY_OPTIMIZATION.is_enabled()

        )
    };

    #[inline]
    fn from_wire(wire: WireControllerGetExposedDictionaryResponse) -> Self {
        Self { dictionary: ::fidl_next::FromWire::from_wire(wire.dictionary) }
    }
}

/// The wire type corresponding to [`ControllerGetExposedDictionaryResponse`].
#[derive(Debug)]
#[repr(C)]
pub struct WireControllerGetExposedDictionaryResponse {
    pub dictionary: ::fidl_next_fuchsia_component_sandbox::WireDictionaryRef,
}

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

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireControllerGetExposedDictionaryResponse
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?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 {
                mut dictionary,

            } = slot;
        }

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

        Ok(())
    }
}

pub type ControllerDestroyResponse = ();

/// The wire type corresponding to [`ControllerDestroyResponse`].
pub type WireControllerDestroyResponse = ();

/// The type corresponding to the Controller protocol.
#[doc = " A protocol used to operate on a component.\n\n One may get access to a `Controller` when creating a component with the\n `Realm.CreateChild` method. You may also obtain a `Controller` for an\n existing child component with the `Realm.OpenController` method.\n"]
#[derive(Debug)]
pub struct Controller;

pub mod controller {
    pub mod prelude {
        pub use crate::{
            controller, Controller, ControllerClientHandler, ControllerClientSender,
            ControllerServerHandler, ControllerServerSender,
        };

        pub use crate::ControllerStartRequest;

        pub use crate::ControllerDestroyResponse;

        pub use crate::ControllerGetExposedDictionaryResponse;

        pub use crate::ControllerIsStartedResponse;

        pub use crate::ControllerStartResponse;

        pub use crate::Error;
    }

    pub struct Start;

    impl ::fidl_next::Method for Start {
        const ORDINAL: u64 = 7532130149195770565;

        type Protocol = crate::Controller;

        type Request = crate::WireControllerStartRequest<'static>;

        type Response = ::fidl_next::WireFlexibleResult<
            'static,
            crate::WireControllerStartResponse,
            crate::WireError,
        >;
    }

    pub struct IsStarted;

    impl ::fidl_next::Method for IsStarted {
        const ORDINAL: u64 = 2402079833990398915;

        type Protocol = crate::Controller;

        type Request = ();

        type Response = ::fidl_next::WireFlexibleResult<
            'static,
            crate::WireControllerIsStartedResponse,
            crate::WireError,
        >;
    }

    pub struct GetExposedDictionary;

    impl ::fidl_next::Method for GetExposedDictionary {
        const ORDINAL: u64 = 9099583788120940443;

        type Protocol = crate::Controller;

        type Request = ();

        type Response = ::fidl_next::WireFlexibleResult<
            'static,
            crate::WireControllerGetExposedDictionaryResponse,
            crate::WireError,
        >;
    }

    pub struct Destroy;

    impl ::fidl_next::Method for Destroy {
        const ORDINAL: u64 = 8381937394141370177;

        type Protocol = crate::Controller;

        type Request = ();

        type Response = ::fidl_next::WireFlexibleResult<
            'static,
            crate::WireControllerDestroyResponse,
            crate::WireError,
        >;
    }
}

/// A helper trait for the `Controller` client sender.
pub trait ControllerClientSender {
    type Transport: ::fidl_next::Transport;

    #[doc = " Start the component, optionally providing additional handles to be given\n to the component. Returns INSTANCE_ALREADY_RUNNING if the instance is\n currently running.\n"]
    fn start<___R>(
        &self,
        request: ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, controller::Start>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireControllerStartRequest<'static>,
        >;

    #[doc = " Returns true if this instance is currently running.\n"]
    fn is_started(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, controller::IsStarted>,
        ::fidl_next::EncodeError,
    >;

    #[doc = " Returns the dictionary containing the component\'s exposed capabilities.\n"]
    fn get_exposed_dictionary(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, controller::GetExposedDictionary>,
        ::fidl_next::EncodeError,
    >;

    #[doc = " Destroys this component. When this method returns, either:\n\n - Ok was returned, indicating destruction has begun.\n - An error was returned, and destruction will not be attempted.\n\n If Ok was returned, destruction will proceed in the background, but it\n hasn\'t necessarily completed yet. When it completes, the framework will\n close this [Controller] channel.\n\n Errors:\n\n - `ACCESS_DENIED`: Destruction of this component is not allowed.\n Currently, this can happen if the component is a static child of its\n parent.\n"]
    fn destroy(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, controller::Destroy>,
        ::fidl_next::EncodeError,
    >;
}

impl<___T> ControllerClientSender for ::fidl_next::ClientSender<___T, Controller>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;

    #[doc = " Start the component, optionally providing additional handles to be given\n to the component. Returns INSTANCE_ALREADY_RUNNING if the instance is\n currently running.\n"]
    fn start<___R>(
        &self,
        request: ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, controller::Start>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireControllerStartRequest<'static>,
        >,
    {
        self.as_untyped()
            .send_two_way(7532130149195770565, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Returns true if this instance is currently running.\n"]
    fn is_started(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, controller::IsStarted>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(2402079833990398915, ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Returns the dictionary containing the component\'s exposed capabilities.\n"]
    fn get_exposed_dictionary(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, controller::GetExposedDictionary>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(9099583788120940443, ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Destroys this component. When this method returns, either:\n\n - Ok was returned, indicating destruction has begun.\n - An error was returned, and destruction will not be attempted.\n\n If Ok was returned, destruction will proceed in the background, but it\n hasn\'t necessarily completed yet. When it completes, the framework will\n close this [Controller] channel.\n\n Errors:\n\n - `ACCESS_DENIED`: Destruction of this component is not allowed.\n Currently, this can happen if the component is a static child of its\n parent.\n"]
    fn destroy(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, controller::Destroy>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(8381937394141370177, ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }
}

/// A client handler for the Controller protocol.
///
/// See [`Controller`] for more details.
pub trait ControllerClientHandler<___T: ::fidl_next::Transport> {
    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ClientSender<___T, Controller>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for Controller
where
    ___T: ::fidl_next::Transport,
    ___H: ControllerClientHandler<___T>,

    <controller::Start as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <controller::IsStarted as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <controller::GetExposedDictionary as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <controller::Destroy 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 `Controller` server sender.
pub trait ControllerServerSender {
    type Transport: ::fidl_next::Transport;
}

impl<___T> ControllerServerSender for ::fidl_next::ServerSender<___T, Controller>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;
}

/// A server handler for the Controller protocol.
///
/// See [`Controller`] for more details.
pub trait ControllerServerHandler<___T: ::fidl_next::Transport> {
    #[doc = " Start the component, optionally providing additional handles to be given\n to the component. Returns INSTANCE_ALREADY_RUNNING if the instance is\n currently running.\n"]
    fn start(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Controller>,

        request: ::fidl_next::Request<___T, controller::Start>,

        responder: ::fidl_next::Responder<controller::Start>,
    );

    #[doc = " Returns true if this instance is currently running.\n"]
    fn is_started(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Controller>,

        responder: ::fidl_next::Responder<controller::IsStarted>,
    );

    #[doc = " Returns the dictionary containing the component\'s exposed capabilities.\n"]
    fn get_exposed_dictionary(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Controller>,

        responder: ::fidl_next::Responder<controller::GetExposedDictionary>,
    );

    #[doc = " Destroys this component. When this method returns, either:\n\n - Ok was returned, indicating destruction has begun.\n - An error was returned, and destruction will not be attempted.\n\n If Ok was returned, destruction will proceed in the background, but it\n hasn\'t necessarily completed yet. When it completes, the framework will\n close this [Controller] channel.\n\n Errors:\n\n - `ACCESS_DENIED`: Destruction of this component is not allowed.\n Currently, this can happen if the component is a static child of its\n parent.\n"]
    fn destroy(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Controller>,

        responder: ::fidl_next::Responder<controller::Destroy>,
    );

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Controller>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for Controller
where
    ___T: ::fidl_next::Transport,
    ___H: ControllerServerHandler<___T>,

    <controller::Start as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            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 {
            7532130149195770565 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.start(sender, decoded, responder),
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            2402079833990398915 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.is_started(sender, responder);
            }

            9099583788120940443 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.get_exposed_dictionary(sender, responder);
            }

            8381937394141370177 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.destroy(sender, responder);
            }

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

#[doc = " The maximum number of dynamic offers that can target a created component.\n"]
pub const MAX_DYNAMIC_OFFER_COUNT: u32 = 128;

#[derive(Debug, Default)]
pub struct CreateChildArgs {
    pub numbered_handles: Option<Vec<::fidl_next_fuchsia_process::HandleInfo>>,

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

    pub controller:
        Option<::fidl_next::ServerEnd<::fidl_next::fuchsia::zx::Channel, crate::Controller>>,

    pub dictionary: Option<::fidl_next_fuchsia_component_sandbox::DictionaryRef>,
}

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

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for CreateChildArgs {
    type Encoded = WireCreateChildArgs<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for CreateChildArgs
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 WireCreateChildArgs { table } = out);

        let max_ord = self.__max_ordinal();

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

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

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

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

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

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

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

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

        Ok(())
    }
}

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

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

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

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

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

        Self {
            numbered_handles:
                numbered_handles.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::WireVector<
                            'de,
                            ::fidl_next_fuchsia_process::WireHandleInfo,
                        >>()
                    })
                }),

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

            controller:
                controller.map(|envelope| {
                    ::fidl_next::FromWire::from_wire(unsafe {
                        envelope.read_unchecked::<::fidl_next::ServerEnd<
                            ::fidl_next::fuchsia::WireChannel,
                            crate::Controller,
                        >>()
                    })
                }),

            dictionary: dictionary.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope
                        .read_unchecked::<::fidl_next_fuchsia_component_sandbox::WireDictionaryRef>(
                        )
                })
            }),
        }
    }
}

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

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

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

        let _ = self.table.get(3)
                .map(|envelope| unsafe {
                    envelope.read_unchecked::<::fidl_next::ServerEnd<::fidl_next::fuchsia::WireChannel,crate::Controller,
        >>()
                });

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

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

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { table } = out);
        ::fidl_next::WireTable::zero_padding(table);
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireCreateChildArgs<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

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

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

                    let numbered_handles = unsafe {
                        slot
                                            .deref_unchecked()
                                            .deref_unchecked::<
                                                ::fidl_next::WireVector<'_, ::fidl_next_fuchsia_process::WireHandleInfo>
                                            >()
                    };

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

                    Ok(())
                }

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

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

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

                    Ok(())
                }

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

                    Ok(())
                }

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

                    Ok(())
                }

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

impl<'de> WireCreateChildArgs<'de> {
    pub fn numbered_handles(
        &self,
    ) -> Option<&::fidl_next::WireVector<'de, ::fidl_next_fuchsia_process::WireHandleInfo>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

    pub fn controller(
        &self,
    ) -> Option<&::fidl_next::ServerEnd<::fidl_next::fuchsia::WireChannel, crate::Controller>> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }

    pub fn dictionary(&self) -> Option<&::fidl_next_fuchsia_component_sandbox::WireDictionaryRef> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireCreateChildArgs<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("CreateChildArgs")
            .field("numbered_handles", &self.numbered_handles())
            .field("dynamic_offers", &self.dynamic_offers())
            .field("controller", &self.controller())
            .field("dictionary", &self.dictionary())
            .finish()
    }
}

#[doc = " Payload for DebugStarted events.\n"]
#[derive(Debug, Default)]
pub struct DebugStartedPayload {
    pub runtime_dir: Option<
        ::fidl_next::ClientEnd<
            ::fidl_next::fuchsia::zx::Channel,
            ::fidl_next_fuchsia_io::Directory,
        >,
    >,

    pub break_on_start: Option<::fidl_next::fuchsia::zx::Handle>,
}

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

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

        0
    }
}

impl ::fidl_next::Encodable for DebugStartedPayload {
    type Encoded = WireDebugStartedPayload<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for DebugStartedPayload
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 WireDebugStartedPayload { table } = out);

        let max_ord = self.__max_ordinal();

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

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

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

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

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

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

        Ok(())
    }
}

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

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

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

        Self {
            runtime_dir: runtime_dir.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::ClientEnd<
                        ::fidl_next::fuchsia::WireChannel,
                        ::fidl_next_fuchsia_io::Directory,
                    >>()
                })
            }),

            break_on_start: break_on_start.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::fuchsia::WireHandle>()
                })
            }),
        }
    }
}

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

impl<'de> Drop for WireDebugStartedPayload<'de> {
    fn drop(&mut self) {
        let _ = self.table.get(1).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next::ClientEnd<
                ::fidl_next::fuchsia::WireChannel,
                ::fidl_next_fuchsia_io::Directory,
            >>()
        });

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

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

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { table } = out);
        ::fidl_next::WireTable::zero_padding(table);
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireDebugStartedPayload<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

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

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::ClientEnd<
                            ::fidl_next::fuchsia::WireChannel,
                            ::fidl_next_fuchsia_io::Directory,
                        >,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

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

                    Ok(())
                }

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

impl<'de> WireDebugStartedPayload<'de> {
    pub fn runtime_dir(
        &self,
    ) -> Option<
        &::fidl_next::ClientEnd<
            ::fidl_next::fuchsia::WireChannel,
            ::fidl_next_fuchsia_io::Directory,
        >,
    > {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

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

impl<'de> ::core::fmt::Debug for WireDebugStartedPayload<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("DebugStartedPayload")
            .field("runtime_dir", &self.runtime_dir())
            .field("break_on_start", &self.break_on_start())
            .finish()
    }
}

#[doc = " Payload for Destroyed events.\n"]
#[derive(Clone, Debug, Default)]
pub struct DestroyedPayload {}

impl DestroyedPayload {
    fn __max_ordinal(&self) -> usize {
        0
    }
}

impl ::fidl_next::Encodable for DestroyedPayload {
    type Encoded = WireDestroyedPayload<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for DestroyedPayload
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 WireDestroyedPayload { table } = out);

        let max_ord = self.__max_ordinal();

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

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

        for i in 1..=max_ord {
            match i {
                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

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

        Ok(())
    }
}

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

        let max_ord = self.__max_ordinal();

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

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

        for i in 1..=max_ord {
            match i {
                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

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

        Ok(())
    }
}

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

        Self {}
    }
}

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

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

impl<'de> Drop for WireDestroyedPayload<'de> {
    fn drop(&mut self) {}
}

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

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { table } = out);
        ::fidl_next::WireTable::zero_padding(table);
    }
}

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

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

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

impl<'de> WireDestroyedPayload<'de> {}

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

#[doc = " Payload for DirectoryReady events\n"]
#[derive(Debug, Default)]
pub struct DirectoryReadyPayload {
    pub name: Option<String>,

    pub node: Option<
        ::fidl_next::ClientEnd<::fidl_next::fuchsia::zx::Channel, ::fidl_next_fuchsia_io::Node>,
    >,
}

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

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

        0
    }
}

impl ::fidl_next::Encodable for DirectoryReadyPayload {
    type Encoded = WireDirectoryReadyPayload<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for DirectoryReadyPayload
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 WireDirectoryReadyPayload { table } = out);

        let max_ord = self.__max_ordinal();

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

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

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

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

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

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

        Ok(())
    }
}

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

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

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

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

            node: node.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::ClientEnd<
                        ::fidl_next::fuchsia::WireChannel,
                        ::fidl_next_fuchsia_io::Node,
                    >>()
                })
            }),
        }
    }
}

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

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

        let _ = self.table.get(2).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next::ClientEnd<
                ::fidl_next::fuchsia::WireChannel,
                ::fidl_next_fuchsia_io::Node,
            >>()
        });
    }
}

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

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { table } = out);
        ::fidl_next::WireTable::zero_padding(table);
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireDirectoryReadyPayload<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

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

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

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

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

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::ClientEnd<
                            ::fidl_next::fuchsia::WireChannel,
                            ::fidl_next_fuchsia_io::Node,
                        >,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

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

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

    pub fn node(
        &self,
    ) -> Option<
        &::fidl_next::ClientEnd<::fidl_next::fuchsia::WireChannel, ::fidl_next_fuchsia_io::Node>,
    > {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }
}

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

#[doc = " Payload for Discovered events.\n"]
#[derive(Clone, Debug, Default)]
pub struct DiscoveredPayload {}

impl DiscoveredPayload {
    fn __max_ordinal(&self) -> usize {
        0
    }
}

impl ::fidl_next::Encodable for DiscoveredPayload {
    type Encoded = WireDiscoveredPayload<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for DiscoveredPayload
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 WireDiscoveredPayload { table } = out);

        let max_ord = self.__max_ordinal();

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

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

        for i in 1..=max_ord {
            match i {
                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

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

        Ok(())
    }
}

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

        let max_ord = self.__max_ordinal();

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

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

        for i in 1..=max_ord {
            match i {
                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

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

        Ok(())
    }
}

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

        Self {}
    }
}

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

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

impl<'de> Drop for WireDiscoveredPayload<'de> {
    fn drop(&mut self) {}
}

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

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { table } = out);
        ::fidl_next::WireTable::zero_padding(table);
    }
}

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

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

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

impl<'de> WireDiscoveredPayload<'de> {}

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

pub const MAX_MONIKER_LENGTH: u32 = 4096;

#[doc = " Payload for Purged events.\n"]
#[derive(Clone, Debug, Default)]
pub struct PurgedPayload {}

impl PurgedPayload {
    fn __max_ordinal(&self) -> usize {
        0
    }
}

impl ::fidl_next::Encodable for PurgedPayload {
    type Encoded = WirePurgedPayload<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for PurgedPayload
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 WirePurgedPayload { table } = out);

        let max_ord = self.__max_ordinal();

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

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

        for i in 1..=max_ord {
            match i {
                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

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

        Ok(())
    }
}

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

        let max_ord = self.__max_ordinal();

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

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

        for i in 1..=max_ord {
            match i {
                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

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

        Ok(())
    }
}

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

        Self {}
    }
}

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

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

impl<'de> Drop for WirePurgedPayload<'de> {
    fn drop(&mut self) {}
}

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

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { table } = out);
        ::fidl_next::WireTable::zero_padding(table);
    }
}

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

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

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

impl<'de> WirePurgedPayload<'de> {}

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

#[doc = " Payload for Resolved events.\n"]
#[derive(Clone, Debug, Default)]
pub struct ResolvedPayload {}

impl ResolvedPayload {
    fn __max_ordinal(&self) -> usize {
        0
    }
}

impl ::fidl_next::Encodable for ResolvedPayload {
    type Encoded = WireResolvedPayload<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for ResolvedPayload
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 WireResolvedPayload { table } = out);

        let max_ord = self.__max_ordinal();

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

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

        for i in 1..=max_ord {
            match i {
                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

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

        Ok(())
    }
}

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

        let max_ord = self.__max_ordinal();

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

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

        for i in 1..=max_ord {
            match i {
                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

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

        Ok(())
    }
}

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

        Self {}
    }
}

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

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

impl<'de> Drop for WireResolvedPayload<'de> {
    fn drop(&mut self) {}
}

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

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { table } = out);
        ::fidl_next::WireTable::zero_padding(table);
    }
}

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

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

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

impl<'de> WireResolvedPayload<'de> {}

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

#[doc = " Payload for Started events.\n"]
#[derive(Clone, Debug, Default)]
pub struct StartedPayload {}

impl StartedPayload {
    fn __max_ordinal(&self) -> usize {
        0
    }
}

impl ::fidl_next::Encodable for StartedPayload {
    type Encoded = WireStartedPayload<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for StartedPayload
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 WireStartedPayload { table } = out);

        let max_ord = self.__max_ordinal();

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

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

        for i in 1..=max_ord {
            match i {
                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

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

        Ok(())
    }
}

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

        let max_ord = self.__max_ordinal();

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

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

        for i in 1..=max_ord {
            match i {
                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

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

        Ok(())
    }
}

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

        Self {}
    }
}

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

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

impl<'de> Drop for WireStartedPayload<'de> {
    fn drop(&mut self) {}
}

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

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { table } = out);
        ::fidl_next::WireTable::zero_padding(table);
    }
}

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

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

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

impl<'de> WireStartedPayload<'de> {}

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

#[doc = " Payload for Unresolved events.\n"]
#[derive(Clone, Debug, Default)]
pub struct UnresolvedPayload {}

impl UnresolvedPayload {
    fn __max_ordinal(&self) -> usize {
        0
    }
}

impl ::fidl_next::Encodable for UnresolvedPayload {
    type Encoded = WireUnresolvedPayload<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for UnresolvedPayload
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 WireUnresolvedPayload { table } = out);

        let max_ord = self.__max_ordinal();

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

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

        for i in 1..=max_ord {
            match i {
                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

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

        Ok(())
    }
}

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

        let max_ord = self.__max_ordinal();

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

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

        for i in 1..=max_ord {
            match i {
                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

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

        Ok(())
    }
}

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

        Self {}
    }
}

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

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

impl<'de> Drop for WireUnresolvedPayload<'de> {
    fn drop(&mut self) {}
}

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

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { table } = out);
        ::fidl_next::WireTable::zero_padding(table);
    }
}

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

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

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

impl<'de> WireUnresolvedPayload<'de> {}

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

#[doc = " Payload for Stopped events.\n"]
#[derive(Clone, Debug, Default)]
pub struct StoppedPayload {
    pub status: Option<i32>,

    pub exit_code: Option<i64>,
}

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

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

        0
    }
}

impl ::fidl_next::Encodable for StoppedPayload {
    type Encoded = WireStoppedPayload<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for StoppedPayload
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 WireStoppedPayload { table } = out);

        let max_ord = self.__max_ordinal();

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

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

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

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

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

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

        Ok(())
    }
}

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

        let max_ord = self.__max_ordinal();

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

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

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

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

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

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

        Ok(())
    }
}

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

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

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

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

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

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

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

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

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

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

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

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { table } = out);
        ::fidl_next::WireTable::zero_padding(table);
    }
}

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

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

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

                    Ok(())
                }

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

                    Ok(())
                }

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

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

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

impl<'de> ::core::fmt::Debug for WireStoppedPayload<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("StoppedPayload")
            .field("status", &self.status())
            .field("exit_code", &self.exit_code())
            .finish()
    }
}

#[doc = " These EventTypes are used for the EventStream protocol.\n They are FIDL versions of the EventType enum in hooks.rs and have\n the same meaning.\n"]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u32)]
pub enum EventType {
    CapabilityRequested = 1,
    DirectoryReady = 2,
    Discovered = 3,
    Destroyed = 4,
    Resolved = 5,
    Started = 6,
    Stopped = 7,
    DebugStarted = 8,
    Unresolved = 9,
}

impl ::fidl_next::Encodable for EventType {
    type Encoded = WireEventType;
}
impl ::std::convert::TryFrom<u32> for EventType {
    type Error = ::fidl_next::UnknownStrictEnumMemberError;
    fn try_from(value: u32) -> Result<Self, Self::Error> {
        match value {
            1 => Ok(Self::CapabilityRequested),
            2 => Ok(Self::DirectoryReady),
            3 => Ok(Self::Discovered),
            4 => Ok(Self::Destroyed),
            5 => Ok(Self::Resolved),
            6 => Ok(Self::Started),
            7 => Ok(Self::Stopped),
            8 => Ok(Self::DebugStarted),
            9 => Ok(Self::Unresolved),

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

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

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

            Self::DirectoryReady => 2,

            Self::Discovered => 3,

            Self::Destroyed => 4,

            Self::Resolved => 5,

            Self::Started => 6,

            Self::Stopped => 7,

            Self::DebugStarted => 8,

            Self::Unresolved => 9,
        }));

        Ok(())
    }
}

impl ::core::convert::From<WireEventType> for EventType {
    fn from(wire: WireEventType) -> Self {
        match u32::from(wire.value) {
            1 => Self::CapabilityRequested,

            2 => Self::DirectoryReady,

            3 => Self::Discovered,

            4 => Self::Destroyed,

            5 => Self::Resolved,

            6 => Self::Started,

            7 => Self::Stopped,

            8 => Self::DebugStarted,

            9 => Self::Unresolved,

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

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

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

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

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

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

impl WireEventType {
    pub const CAPABILITY_REQUESTED: WireEventType =
        WireEventType { value: ::fidl_next::WireU32(1) };

    pub const DIRECTORY_READY: WireEventType = WireEventType { value: ::fidl_next::WireU32(2) };

    pub const DISCOVERED: WireEventType = WireEventType { value: ::fidl_next::WireU32(3) };

    pub const DESTROYED: WireEventType = WireEventType { value: ::fidl_next::WireU32(4) };

    pub const RESOLVED: WireEventType = WireEventType { value: ::fidl_next::WireU32(5) };

    pub const STARTED: WireEventType = WireEventType { value: ::fidl_next::WireU32(6) };

    pub const STOPPED: WireEventType = WireEventType { value: ::fidl_next::WireU32(7) };

    pub const DEBUG_STARTED: WireEventType = WireEventType { value: ::fidl_next::WireU32(8) };

    pub const UNRESOLVED: WireEventType = WireEventType { value: ::fidl_next::WireU32(9) };
}

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

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

        Ok(())
    }
}

impl ::core::convert::From<EventType> for WireEventType {
    fn from(natural: EventType) -> Self {
        match natural {
            EventType::CapabilityRequested => WireEventType::CAPABILITY_REQUESTED,

            EventType::DirectoryReady => WireEventType::DIRECTORY_READY,

            EventType::Discovered => WireEventType::DISCOVERED,

            EventType::Destroyed => WireEventType::DESTROYED,

            EventType::Resolved => WireEventType::RESOLVED,

            EventType::Started => WireEventType::STARTED,

            EventType::Stopped => WireEventType::STOPPED,

            EventType::DebugStarted => WireEventType::DEBUG_STARTED,

            EventType::Unresolved => WireEventType::UNRESOLVED,
        }
    }
}

#[doc = " A head providing metadata about a target component instance.\n"]
#[derive(Clone, Debug, Default)]
pub struct EventHeader {
    pub event_type: Option<crate::EventType>,

    pub moniker: Option<String>,

    pub component_url: Option<String>,

    pub timestamp: Option<i64>,
}

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

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for EventHeader {
    type Encoded = WireEventHeader<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for EventHeader
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 WireEventHeader { table } = out);

        let max_ord = self.__max_ordinal();

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

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

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

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

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

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

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

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

        Ok(())
    }
}

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

        let max_ord = self.__max_ordinal();

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

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

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

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

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

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

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

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

        Ok(())
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { table } = out);
        ::fidl_next::WireTable::zero_padding(table);
    }
}

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

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

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

                    Ok(())
                }

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

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

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

                    Ok(())
                }

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

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

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

                    Ok(())
                }

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

                    Ok(())
                }

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

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

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

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

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

impl<'de> ::core::fmt::Debug for WireEventHeader<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("EventHeader")
            .field("event_type", &self.event_type())
            .field("moniker", &self.moniker())
            .field("component_url", &self.component_url())
            .field("timestamp", &self.timestamp())
            .finish()
    }
}

#[doc = " Encapsulates additional data/protocols for some event types.\n"]
#[derive(Debug)]
pub enum EventPayload {
    CapabilityRequested(crate::CapabilityRequestedPayload),

    Purged(crate::PurgedPayload),

    DirectoryReady(crate::DirectoryReadyPayload),

    Discovered(crate::DiscoveredPayload),

    Destroyed(crate::DestroyedPayload),

    Resolved(crate::ResolvedPayload),

    Started(crate::StartedPayload),

    Stopped(crate::StoppedPayload),

    DebugStarted(crate::DebugStartedPayload),

    Unresolved(crate::UnresolvedPayload),

    UnknownOrdinal_(u64),
}

impl ::fidl_next::Encodable for EventPayload {
    type Encoded = WireEventPayload<'static>;
}

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

    ___E: ::fidl_next::Encoder,

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

        match self {
            Self::CapabilityRequested(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                crate::CapabilityRequestedPayload,
            >(value, 1, encoder, raw)?,

            Self::Purged(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                crate::PurgedPayload,
            >(value, 2, encoder, raw)?,

            Self::DirectoryReady(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                crate::DirectoryReadyPayload,
            >(value, 3, encoder, raw)?,

            Self::Discovered(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                crate::DiscoveredPayload,
            >(value, 4, encoder, raw)?,

            Self::Destroyed(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                crate::DestroyedPayload,
            >(value, 5, encoder, raw)?,

            Self::Resolved(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                crate::ResolvedPayload,
            >(value, 6, encoder, raw)?,

            Self::Started(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                crate::StartedPayload,
            >(value, 7, encoder, raw)?,

            Self::Stopped(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                crate::StoppedPayload,
            >(value, 8, encoder, raw)?,

            Self::DebugStarted(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                crate::DebugStartedPayload,
            >(value, 9, encoder, raw)?,

            Self::Unresolved(value) => ::fidl_next::RawWireUnion::encode_as::<
                ___E,
                crate::UnresolvedPayload,
            >(value, 10, encoder, raw)?,

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for EventPayload {
    type EncodedOption = WireOptionalEventPayload<'static>;
}

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

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

        Ok(())
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            6 => {
                let _ =
                    unsafe { self.raw.get().read_unchecked::<crate::WireResolvedPayload<'de>>() };
            }

            7 => {
                let _ =
                    unsafe { self.raw.get().read_unchecked::<crate::WireStartedPayload<'de>>() };
            }

            8 => {
                let _ =
                    unsafe { self.raw.get().read_unchecked::<crate::WireStoppedPayload<'de>>() };
            }

            9 => {
                let _ = unsafe {
                    self.raw.get().read_unchecked::<crate::WireDebugStartedPayload<'de>>()
                };
            }

            10 => {
                let _ =
                    unsafe { self.raw.get().read_unchecked::<crate::WireUnresolvedPayload<'de>>() };
            }

            _ => (),
        }
    }
}

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

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
        ::fidl_next::RawWireUnion::zero_padding(raw);
    }
}

pub mod event_payload {
    pub enum Ref<'de> {
        CapabilityRequested(&'de crate::WireCapabilityRequestedPayload<'de>),

        Purged(&'de crate::WirePurgedPayload<'de>),

        DirectoryReady(&'de crate::WireDirectoryReadyPayload<'de>),

        Discovered(&'de crate::WireDiscoveredPayload<'de>),

        Destroyed(&'de crate::WireDestroyedPayload<'de>),

        Resolved(&'de crate::WireResolvedPayload<'de>),

        Started(&'de crate::WireStartedPayload<'de>),

        Stopped(&'de crate::WireStoppedPayload<'de>),

        DebugStarted(&'de crate::WireDebugStartedPayload<'de>),

        Unresolved(&'de crate::WireUnresolvedPayload<'de>),

        UnknownOrdinal_(u64),
    }
}

impl<'de> WireEventPayload<'de> {
    pub fn as_ref(&self) -> crate::event_payload::Ref<'_> {
        match self.raw.ordinal() {
            1 => crate::event_payload::Ref::CapabilityRequested(unsafe {
                self.raw.get().deref_unchecked::<crate::WireCapabilityRequestedPayload<'_>>()
            }),

            2 => crate::event_payload::Ref::Purged(unsafe {
                self.raw.get().deref_unchecked::<crate::WirePurgedPayload<'_>>()
            }),

            3 => crate::event_payload::Ref::DirectoryReady(unsafe {
                self.raw.get().deref_unchecked::<crate::WireDirectoryReadyPayload<'_>>()
            }),

            4 => crate::event_payload::Ref::Discovered(unsafe {
                self.raw.get().deref_unchecked::<crate::WireDiscoveredPayload<'_>>()
            }),

            5 => crate::event_payload::Ref::Destroyed(unsafe {
                self.raw.get().deref_unchecked::<crate::WireDestroyedPayload<'_>>()
            }),

            6 => crate::event_payload::Ref::Resolved(unsafe {
                self.raw.get().deref_unchecked::<crate::WireResolvedPayload<'_>>()
            }),

            7 => crate::event_payload::Ref::Started(unsafe {
                self.raw.get().deref_unchecked::<crate::WireStartedPayload<'_>>()
            }),

            8 => crate::event_payload::Ref::Stopped(unsafe {
                self.raw.get().deref_unchecked::<crate::WireStoppedPayload<'_>>()
            }),

            9 => crate::event_payload::Ref::DebugStarted(unsafe {
                self.raw.get().deref_unchecked::<crate::WireDebugStartedPayload<'_>>()
            }),

            10 => crate::event_payload::Ref::Unresolved(unsafe {
                self.raw.get().deref_unchecked::<crate::WireUnresolvedPayload<'_>>()
            }),

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

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

    ___D: ::fidl_next::Decoder,

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

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

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

            4 => {
                ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireDiscoveredPayload<'static>>(
                    raw, decoder,
                )?
            }

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

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

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

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

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

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

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

        Ok(())
    }
}

impl<'de> ::core::fmt::Debug for WireEventPayload<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        match self.raw.ordinal() {
            1 => unsafe {
                self.raw.get().deref_unchecked::<crate::WireCapabilityRequestedPayload<'_>>().fmt(f)
            },
            2 => unsafe { self.raw.get().deref_unchecked::<crate::WirePurgedPayload<'_>>().fmt(f) },
            3 => unsafe {
                self.raw.get().deref_unchecked::<crate::WireDirectoryReadyPayload<'_>>().fmt(f)
            },
            4 => unsafe {
                self.raw.get().deref_unchecked::<crate::WireDiscoveredPayload<'_>>().fmt(f)
            },
            5 => unsafe {
                self.raw.get().deref_unchecked::<crate::WireDestroyedPayload<'_>>().fmt(f)
            },
            6 => unsafe {
                self.raw.get().deref_unchecked::<crate::WireResolvedPayload<'_>>().fmt(f)
            },
            7 => unsafe {
                self.raw.get().deref_unchecked::<crate::WireStartedPayload<'_>>().fmt(f)
            },
            8 => unsafe {
                self.raw.get().deref_unchecked::<crate::WireStoppedPayload<'_>>().fmt(f)
            },
            9 => unsafe {
                self.raw.get().deref_unchecked::<crate::WireDebugStartedPayload<'_>>().fmt(f)
            },
            10 => unsafe {
                self.raw.get().deref_unchecked::<crate::WireUnresolvedPayload<'_>>().fmt(f)
            },
            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

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

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

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
        ::fidl_next::RawWireUnion::zero_padding(raw);
    }
}

impl<'de> WireOptionalEventPayload<'de> {
    pub fn is_some(&self) -> bool {
        self.raw.is_some()
    }

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

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

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

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

    ___D: ::fidl_next::Decoder,

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

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

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

            4 => {
                ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireDiscoveredPayload<'static>>(
                    raw, decoder,
                )?
            }

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

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

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

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

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

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

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

        Ok(())
    }
}

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

#[doc = " Contains all information about a single event\n"]
#[derive(Debug, Default)]
pub struct Event {
    pub header: Option<crate::EventHeader>,

    pub payload: Option<crate::EventPayload>,
}

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

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

        0
    }
}

impl ::fidl_next::Encodable for Event {
    type Encoded = WireEvent<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for Event
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 WireEvent { table } = out);

        let max_ord = self.__max_ordinal();

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

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

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

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

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

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

        Ok(())
    }
}

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

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

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

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

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

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

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

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

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

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { table } = out);
        ::fidl_next::WireTable::zero_padding(table);
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireEvent<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

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

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

                    Ok(())
                }

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

                    Ok(())
                }

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

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

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

impl<'de> ::core::fmt::Debug for WireEvent<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("Event")
            .field("header", &self.header())
            .field("payload", &self.payload())
            .finish()
    }
}

#[derive(Debug)]
pub struct EventStreamGetNextResponse {
    pub events: Vec<crate::Event>,
}

impl ::fidl_next::Encodable for EventStreamGetNextResponse {
    type Encoded = WireEventStreamGetNextResponse<'static>;
}

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

    ___E: ::fidl_next::Encoder,

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

            } = out;
        }

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

impl<'de> ::fidl_next::FromWire<WireEventStreamGetNextResponse<'de>>
    for EventStreamGetNextResponse
{
    #[inline]
    fn from_wire(wire: WireEventStreamGetNextResponse<'de>) -> Self {
        Self { events: ::fidl_next::FromWire::from_wire(wire.events) }
    }
}

/// The wire type corresponding to [`EventStreamGetNextResponse`].
#[derive(Debug)]
#[repr(C)]
pub struct WireEventStreamGetNextResponse<'de> {
    pub events: ::fidl_next::WireVector<'de, crate::WireEvent<'de>>,
}

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

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

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

    ___D: ::fidl_next::Decoder,

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

            } = slot;
        }

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

        Ok(())
    }
}

/// The type corresponding to the EventStream protocol.
#[doc = " Listener for events on the component hierarchy.\n Can\'t be used outside of the platform.\n"]
#[derive(Debug)]
pub struct EventStream;

impl ::fidl_next::Discoverable for EventStream {
    const PROTOCOL_NAME: &'static str = "fuchsia.component.EventStream";
}

pub mod event_stream {
    pub mod prelude {
        pub use crate::{
            event_stream, EventStream, EventStreamClientHandler, EventStreamClientSender,
            EventStreamServerHandler, EventStreamServerSender,
        };

        pub use crate::EventStreamGetNextResponse;
    }

    pub struct GetNext;

    impl ::fidl_next::Method for GetNext {
        const ORDINAL: u64 = 4549982840421936006;

        type Protocol = crate::EventStream;

        type Request = ();

        type Response = crate::WireEventStreamGetNextResponse<'static>;
    }

    pub struct WaitForReady;

    impl ::fidl_next::Method for WaitForReady {
        const ORDINAL: u64 = 3545212058508387970;

        type Protocol = crate::EventStream;

        type Request = ();

        type Response = ();
    }
}

/// A helper trait for the `EventStream` client sender.
pub trait EventStreamClientSender {
    type Transport: ::fidl_next::Transport;

    fn get_next(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, event_stream::GetNext>,
        ::fidl_next::EncodeError,
    >;

    #[doc = " Returns immediately. Used to indicate that the FIDL connection\n completed. This is needed for non-static streams to verify\n that subscribe has completed before components are started.\n"]
    fn wait_for_ready(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, event_stream::WaitForReady>,
        ::fidl_next::EncodeError,
    >;
}

impl<___T> EventStreamClientSender for ::fidl_next::ClientSender<___T, EventStream>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;

    fn get_next(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, event_stream::GetNext>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(4549982840421936006, ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Returns immediately. Used to indicate that the FIDL connection\n completed. This is needed for non-static streams to verify\n that subscribe has completed before components are started.\n"]
    fn wait_for_ready(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, event_stream::WaitForReady>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(3545212058508387970, ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }
}

/// A client handler for the EventStream protocol.
///
/// See [`EventStream`] for more details.
pub trait EventStreamClientHandler<___T: ::fidl_next::Transport> {}

impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for EventStream
where
    ___T: ::fidl_next::Transport,
    ___H: EventStreamClientHandler<___T>,

    <event_stream::GetNext 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 => {
                sender.close();
            }
        }
    }
}

/// A helper trait for the `EventStream` server sender.
pub trait EventStreamServerSender {
    type Transport: ::fidl_next::Transport;
}

impl<___T> EventStreamServerSender for ::fidl_next::ServerSender<___T, EventStream>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;
}

/// A server handler for the EventStream protocol.
///
/// See [`EventStream`] for more details.
pub trait EventStreamServerHandler<___T: ::fidl_next::Transport> {
    fn get_next(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, EventStream>,

        responder: ::fidl_next::Responder<event_stream::GetNext>,
    );

    #[doc = " Returns immediately. Used to indicate that the FIDL connection\n completed. This is needed for non-static streams to verify\n that subscribe has completed before components are started.\n"]
    fn wait_for_ready(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, EventStream>,

        responder: ::fidl_next::Responder<event_stream::WaitForReady>,
    );
}

impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for EventStream
where
    ___T: ::fidl_next::Transport,
    ___H: EventStreamServerHandler<___T>,
{
    fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => {
                sender.close();
            }
        }
    }

    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 {
            4549982840421936006 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.get_next(sender, responder);
            }

            3545212058508387970 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.wait_for_ready(sender, responder);
            }

            ordinal => {
                sender.close();
            }
        }
    }
}

#[derive(Clone, Debug)]
pub struct ExecutionControllerOnStopRequest {
    pub stopped_payload: crate::StoppedPayload,
}

impl ::fidl_next::Encodable for ExecutionControllerOnStopRequest {
    type Encoded = WireExecutionControllerOnStopRequest<'static>;
}

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

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

            } = out;
        }

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

        Ok(())
    }
}

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

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

            } = out;
        }

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

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

        Ok(())
    }
}

impl<'de> ::fidl_next::FromWire<WireExecutionControllerOnStopRequest<'de>>
    for ExecutionControllerOnStopRequest
{
    #[inline]
    fn from_wire(wire: WireExecutionControllerOnStopRequest<'de>) -> Self {
        Self { stopped_payload: ::fidl_next::FromWire::from_wire(wire.stopped_payload) }
    }
}

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

/// The wire type corresponding to [`ExecutionControllerOnStopRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireExecutionControllerOnStopRequest<'de> {
    pub stopped_payload: crate::WireStoppedPayload<'de>,
}

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

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

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

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

            } = slot;
        }

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

        Ok(())
    }
}

/// The type corresponding to the ExecutionController protocol.
#[derive(Debug)]
pub struct ExecutionController;

pub mod execution_controller {
    pub mod prelude {
        pub use crate::{
            execution_controller, ExecutionController, ExecutionControllerClientHandler,
            ExecutionControllerClientSender, ExecutionControllerServerHandler,
            ExecutionControllerServerSender,
        };

        pub use crate::ExecutionControllerOnStopRequest;
    }

    pub struct Stop;

    impl ::fidl_next::Method for Stop {
        const ORDINAL: u64 = 6256129817234858263;

        type Protocol = crate::ExecutionController;

        type Request = ();

        type Response = ::fidl_next::Never;
    }

    pub struct OnStop;

    impl ::fidl_next::Method for OnStop {
        const ORDINAL: u64 = 7121600095714604415;

        type Protocol = crate::ExecutionController;

        type Request = ::fidl_next::Never;

        type Response = crate::WireExecutionControllerOnStopRequest<'static>;
    }
}

/// A helper trait for the `ExecutionController` client sender.
pub trait ExecutionControllerClientSender {
    type Transport: ::fidl_next::Transport;

    #[doc = " Initiates a stop action on this component. Once complete, OnStop will be\n called with the stopped payload and this channel is closed.\n\n Note that a component may stop running on its own at any time, so it is\n possible for `OnStop` to be received before `Stop` is called.\n"]
    fn stop(
        &self,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>;
}

impl<___T> ExecutionControllerClientSender for ::fidl_next::ClientSender<___T, ExecutionController>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;

    #[doc = " Initiates a stop action on this component. Once complete, OnStop will be\n called with the stopped payload and this channel is closed.\n\n Note that a component may stop running on its own at any time, so it is\n possible for `OnStop` to be received before `Stop` is called.\n"]
    fn stop(
        &self,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError> {
        self.as_untyped().send_one_way(6256129817234858263, ())
    }
}

/// A client handler for the ExecutionController protocol.
///
/// See [`ExecutionController`] for more details.
pub trait ExecutionControllerClientHandler<___T: ::fidl_next::Transport> {
    #[doc = " When the child is stopped due to `Stop` being called, the child exiting\n on its own, or for any other reason, `OnStop` is called and then this\n channel is closed.\n"]
    fn on_stop(
        &mut self,
        sender: &::fidl_next::ClientSender<___T, ExecutionController>,

        event: ::fidl_next::Response<___T, execution_controller::OnStop>,
    );

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ClientSender<___T, ExecutionController>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for ExecutionController
where
    ___T: ::fidl_next::Transport,
    ___H: ExecutionControllerClientHandler<___T>,

    <execution_controller::OnStop 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 {
            7121600095714604415 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => handler.on_stop(sender, decoded),
                Err(e) => {
                    sender.close();
                }
            },

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

/// A helper trait for the `ExecutionController` server sender.
pub trait ExecutionControllerServerSender {
    type Transport: ::fidl_next::Transport;

    #[doc = " When the child is stopped due to `Stop` being called, the child exiting\n on its own, or for any other reason, `OnStop` is called and then this\n channel is closed.\n"]

    fn on_stop<___R>(
        &self,
        request: ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = <execution_controller::OnStop as ::fidl_next::Method>::Response,
        >;
}

impl<___T> ExecutionControllerServerSender for ::fidl_next::ServerSender<___T, ExecutionController>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;

    #[doc = " When the child is stopped due to `Stop` being called, the child exiting\n on its own, or for any other reason, `OnStop` is called and then this\n channel is closed.\n"]

    fn on_stop<___R>(
        &self,
        request: ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = <execution_controller::OnStop as ::fidl_next::Method>::Response,
        >,
    {
        self.as_untyped().send_event(7121600095714604415, request)
    }
}

/// A server handler for the ExecutionController protocol.
///
/// See [`ExecutionController`] for more details.
pub trait ExecutionControllerServerHandler<___T: ::fidl_next::Transport> {
    #[doc = " Initiates a stop action on this component. Once complete, OnStop will be\n called with the stopped payload and this channel is closed.\n\n Note that a component may stop running on its own at any time, so it is\n possible for `OnStop` to be received before `Stop` is called.\n"]
    fn stop(&mut self, sender: &::fidl_next::ServerSender<___T, ExecutionController>);

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, ExecutionController>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for ExecutionController
where
    ___T: ::fidl_next::Transport,
    ___H: ExecutionControllerServerHandler<___T>,
{
    fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            6256129817234858263 => {
                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 {
            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }
}

#[derive(Debug)]
#[repr(C)]
pub struct IntrospectorGetMonikerRequest {
    pub component_instance: ::fidl_next::fuchsia::zx::Handle,
}

impl ::fidl_next::Encodable for IntrospectorGetMonikerRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
        Self,
        WireIntrospectorGetMonikerRequest,
    > = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <::fidl_next::fuchsia::zx::Handle as ::fidl_next::Encodable>::COPY_OPTIMIZATION
                .is_enabled(),
        )
    };

    type Encoded = WireIntrospectorGetMonikerRequest;
}

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

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

            } = out;
        }

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

impl ::fidl_next::FromWire<WireIntrospectorGetMonikerRequest> for IntrospectorGetMonikerRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
        WireIntrospectorGetMonikerRequest,
        Self,
    > = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <::fidl_next::fuchsia::zx::Handle as ::fidl_next::FromWire<
                ::fidl_next::fuchsia::WireHandle,
            >>::COPY_OPTIMIZATION
                .is_enabled(),
        )
    };

    #[inline]
    fn from_wire(wire: WireIntrospectorGetMonikerRequest) -> Self {
        Self { component_instance: ::fidl_next::FromWire::from_wire(wire.component_instance) }
    }
}

/// The wire type corresponding to [`IntrospectorGetMonikerRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireIntrospectorGetMonikerRequest {
    pub component_instance: ::fidl_next::fuchsia::WireHandle,
}

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

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireIntrospectorGetMonikerRequest
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?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 {
                mut component_instance,

            } = slot;
        }

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

        Ok(())
    }
}

#[derive(Clone, Debug)]
pub struct IntrospectorGetMonikerResponse {
    pub moniker: String,
}

impl ::fidl_next::Encodable for IntrospectorGetMonikerResponse {
    type Encoded = WireIntrospectorGetMonikerResponse<'static>;
}

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

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

            } = out;
        }

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

        Ok(())
    }
}

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

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

            } = out;
        }

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

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

        Ok(())
    }
}

impl<'de> ::fidl_next::FromWire<WireIntrospectorGetMonikerResponse<'de>>
    for IntrospectorGetMonikerResponse
{
    #[inline]
    fn from_wire(wire: WireIntrospectorGetMonikerResponse<'de>) -> Self {
        Self { moniker: ::fidl_next::FromWire::from_wire(wire.moniker) }
    }
}

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

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

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

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

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

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

            } = slot;
        }

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

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

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

        Ok(())
    }
}

/// The type corresponding to the Introspector protocol.
#[doc = " A protocol used by a component instance to obtain information about\n components in its own realm.\n\n This protocol only supports getting the moniker at the moment but could\n expand to other privileged information such as the URL of a component.\n\n The component framework provides this capability to components that use\n `fuchsia.component.Introspector` from framework.\n"]
#[derive(Debug)]
pub struct Introspector;

impl ::fidl_next::Discoverable for Introspector {
    const PROTOCOL_NAME: &'static str = "fuchsia.component.Introspector";
}

pub mod introspector {
    pub mod prelude {
        pub use crate::{
            introspector, Introspector, IntrospectorClientHandler, IntrospectorClientSender,
            IntrospectorServerHandler, IntrospectorServerSender,
        };

        pub use crate::Error;

        pub use crate::IntrospectorGetMonikerRequest;

        pub use crate::IntrospectorGetMonikerResponse;
    }

    pub struct GetMoniker;

    impl ::fidl_next::Method for GetMoniker {
        const ORDINAL: u64 = 214344082539672664;

        type Protocol = crate::Introspector;

        type Request = crate::WireIntrospectorGetMonikerRequest;

        type Response = ::fidl_next::WireFlexibleResult<
            'static,
            crate::WireIntrospectorGetMonikerResponse<'static>,
            crate::WireError,
        >;
    }
}

/// A helper trait for the `Introspector` client sender.
pub trait IntrospectorClientSender {
    type Transport: ::fidl_next::Transport;

    #[doc = " Obtains the moniker relative to this realm of the component\n corresponding to the provided token. Runners may obtain the token via\n `fuchsia.component.runner/ComponentStartInfo.component_instance`.\n\n Returns `Error.INSTANCE_NOT_FOUND` if the token is invalid, or\n does not correspond to a component under this realm.\n"]
    fn get_moniker<___R>(
        &self,
        request: ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, introspector::GetMoniker>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireIntrospectorGetMonikerRequest,
        >;
}

impl<___T> IntrospectorClientSender for ::fidl_next::ClientSender<___T, Introspector>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;

    #[doc = " Obtains the moniker relative to this realm of the component\n corresponding to the provided token. Runners may obtain the token via\n `fuchsia.component.runner/ComponentStartInfo.component_instance`.\n\n Returns `Error.INSTANCE_NOT_FOUND` if the token is invalid, or\n does not correspond to a component under this realm.\n"]
    fn get_moniker<___R>(
        &self,
        request: ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, introspector::GetMoniker>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireIntrospectorGetMonikerRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(214344082539672664, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }
}

/// A client handler for the Introspector protocol.
///
/// See [`Introspector`] for more details.
pub trait IntrospectorClientHandler<___T: ::fidl_next::Transport> {
    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ClientSender<___T, Introspector>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for Introspector
where
    ___T: ::fidl_next::Transport,
    ___H: IntrospectorClientHandler<___T>,

    <introspector::GetMoniker 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 `Introspector` server sender.
pub trait IntrospectorServerSender {
    type Transport: ::fidl_next::Transport;
}

impl<___T> IntrospectorServerSender for ::fidl_next::ServerSender<___T, Introspector>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;
}

/// A server handler for the Introspector protocol.
///
/// See [`Introspector`] for more details.
pub trait IntrospectorServerHandler<___T: ::fidl_next::Transport> {
    #[doc = " Obtains the moniker relative to this realm of the component\n corresponding to the provided token. Runners may obtain the token via\n `fuchsia.component.runner/ComponentStartInfo.component_instance`.\n\n Returns `Error.INSTANCE_NOT_FOUND` if the token is invalid, or\n does not correspond to a component under this realm.\n"]
    fn get_moniker(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Introspector>,

        request: ::fidl_next::Request<___T, introspector::GetMoniker>,

        responder: ::fidl_next::Responder<introspector::GetMoniker>,
    );

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Introspector>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for Introspector
where
    ___T: ::fidl_next::Transport,
    ___H: IntrospectorServerHandler<___T>,

    <introspector::GetMoniker as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }

    fn on_two_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
        responder: ::fidl_next::protocol::Responder,
    ) {
        match ordinal {
            214344082539672664 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.get_moniker(sender, decoded, responder),
                    Err(e) => {
                        sender.close();
                    }
                }
            }

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

#[doc = " The maximum string length of a capability ID.\n This value is currently set arbitrarily.\n"]
pub const MAX_CAPABILITY_ID_LENGTH: u64 = 50;

pub const MAX_CHILD_NAME_LENGTH: u32 = 1024;

#[doc = " The maximum string length of an error description.\n"]
pub const MAX_ERROR_DESCRIPTION_LENGTH: u64 = 100;

#[doc = " The maximum number of events that a receiver can listen to.\n"]
pub const MAX_NUM_EVENTS_RECEIVED: u64 = 100;

#[doc = " The maximum number of requests per event subscription.\n"]
pub const MAX_SUBSCRIPTION_REQUESTS: u32 = 2;

pub const MAX_URL_SCHEME_LENGTH: u64 = 255;

#[derive(Debug)]
pub struct NamespaceInputEntry {
    pub path: String,

    pub dictionary: ::fidl_next::ClientEnd<
        ::fidl_next::fuchsia::zx::Channel,
        ::fidl_next_fuchsia_component_sandbox::Dictionary,
    >,
}

impl ::fidl_next::Encodable for NamespaceInputEntry {
    type Encoded = WireNamespaceInputEntry<'static>;
}

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

    ___E: ::fidl_next::Encoder,

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

            } = out;
        }

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

impl<'de> ::fidl_next::FromWire<WireNamespaceInputEntry<'de>> for NamespaceInputEntry {
    #[inline]
    fn from_wire(wire: WireNamespaceInputEntry<'de>) -> Self {
        Self {
            path: ::fidl_next::FromWire::from_wire(wire.path),

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

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

    pub dictionary: ::fidl_next::ClientEnd<
        ::fidl_next::fuchsia::WireChannel,
        ::fidl_next_fuchsia_component_sandbox::Dictionary,
    >,
}

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

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

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

    ___D: ::fidl_next::Decoder,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut path,
                mut dictionary,

            } = slot;
        }

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

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

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

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

        Ok(())
    }
}

#[derive(Debug)]
pub struct NamespaceCreateRequest {
    pub entries: Vec<crate::NamespaceInputEntry>,
}

impl ::fidl_next::Encodable for NamespaceCreateRequest {
    type Encoded = WireNamespaceCreateRequest<'static>;
}

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

    ___E: ::fidl_next::Encoder,

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

            } = out;
        }

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

impl<'de> ::fidl_next::FromWire<WireNamespaceCreateRequest<'de>> for NamespaceCreateRequest {
    #[inline]
    fn from_wire(wire: WireNamespaceCreateRequest<'de>) -> Self {
        Self { entries: ::fidl_next::FromWire::from_wire(wire.entries) }
    }
}

/// The wire type corresponding to [`NamespaceCreateRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireNamespaceCreateRequest<'de> {
    pub entries: ::fidl_next::WireVector<'de, crate::WireNamespaceInputEntry<'de>>,
}

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

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

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

    ___D: ::fidl_next::Decoder,

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

            } = slot;
        }

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

        Ok(())
    }
}

#[doc = " Error returned from methods in [`Namespace`].\n"]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u32)]
pub enum NamespaceError {
    Shadow = 1,
    Duplicate = 2,
    Conversion = 3,
    BadEntry = 4,
    DictionaryRead = 5,
    UnknownOrdinal_(u32),
}

impl ::fidl_next::Encodable for NamespaceError {
    type Encoded = WireNamespaceError;
}
impl ::std::convert::From<u32> for NamespaceError {
    fn from(value: u32) -> Self {
        match value {
            1 => Self::Shadow,
            2 => Self::Duplicate,
            3 => Self::Conversion,
            4 => Self::BadEntry,
            5 => Self::DictionaryRead,

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

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

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

            Self::Duplicate => 2,

            Self::Conversion => 3,

            Self::BadEntry => 4,

            Self::DictionaryRead => 5,

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

        Ok(())
    }
}

impl ::core::convert::From<WireNamespaceError> for NamespaceError {
    fn from(wire: WireNamespaceError) -> Self {
        match u32::from(wire.value) {
            1 => Self::Shadow,

            2 => Self::Duplicate,

            3 => Self::Conversion,

            4 => Self::BadEntry,

            5 => Self::DictionaryRead,

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

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

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

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

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

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

impl WireNamespaceError {
    pub const SHADOW: WireNamespaceError = WireNamespaceError { value: ::fidl_next::WireU32(1) };

    pub const DUPLICATE: WireNamespaceError = WireNamespaceError { value: ::fidl_next::WireU32(2) };

    pub const CONVERSION: WireNamespaceError =
        WireNamespaceError { value: ::fidl_next::WireU32(3) };

    pub const BAD_ENTRY: WireNamespaceError = WireNamespaceError { value: ::fidl_next::WireU32(4) };

    pub const DICTIONARY_READ: WireNamespaceError =
        WireNamespaceError { value: ::fidl_next::WireU32(5) };
}

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

impl ::core::convert::From<NamespaceError> for WireNamespaceError {
    fn from(natural: NamespaceError) -> Self {
        match natural {
            NamespaceError::Shadow => WireNamespaceError::SHADOW,

            NamespaceError::Duplicate => WireNamespaceError::DUPLICATE,

            NamespaceError::Conversion => WireNamespaceError::CONVERSION,

            NamespaceError::BadEntry => WireNamespaceError::BAD_ENTRY,

            NamespaceError::DictionaryRead => WireNamespaceError::DICTIONARY_READ,

            NamespaceError::UnknownOrdinal_(value) => {
                WireNamespaceError { value: ::fidl_next::WireU32::from(value) }
            }
        }
    }
}

#[derive(Debug)]
pub struct NamespaceCreateResponse {
    pub entries: Vec<crate::NamespaceEntry>,
}

impl ::fidl_next::Encodable for NamespaceCreateResponse {
    type Encoded = WireNamespaceCreateResponse<'static>;
}

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

    ___E: ::fidl_next::Encoder,

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

            } = out;
        }

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

impl<'de> ::fidl_next::FromWire<WireNamespaceCreateResponse<'de>> for NamespaceCreateResponse {
    #[inline]
    fn from_wire(wire: WireNamespaceCreateResponse<'de>) -> Self {
        Self { entries: ::fidl_next::FromWire::from_wire(wire.entries) }
    }
}

/// The wire type corresponding to [`NamespaceCreateResponse`].
#[derive(Debug)]
#[repr(C)]
pub struct WireNamespaceCreateResponse<'de> {
    pub entries: ::fidl_next::WireVector<'de, crate::WireNamespaceEntry<'de>>,
}

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

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

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

    ___D: ::fidl_next::Decoder,

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

            } = slot;
        }

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

        Ok(())
    }
}

/// The type corresponding to the Namespace protocol.
#[doc = " Protocol for performing namespace operations.\n"]
#[derive(Debug)]
pub struct Namespace;

impl ::fidl_next::Discoverable for Namespace {
    const PROTOCOL_NAME: &'static str = "fuchsia.component.Namespace";
}

pub mod namespace {
    pub mod prelude {
        pub use crate::{
            namespace, Namespace, NamespaceClientHandler, NamespaceClientSender,
            NamespaceServerHandler, NamespaceServerSender,
        };

        pub use crate::NamespaceCreateRequest;

        pub use crate::NamespaceError;

        pub use crate::NamespaceCreateResponse;
    }

    pub struct Create;

    impl ::fidl_next::Method for Create {
        const ORDINAL: u64 = 4839678630846501113;

        type Protocol = crate::Namespace;

        type Request = crate::WireNamespaceCreateRequest<'static>;

        type Response = ::fidl_next::WireFlexibleResult<
            'static,
            crate::WireNamespaceCreateResponse<'static>,
            crate::WireNamespaceError,
        >;
    }
}

/// A helper trait for the `Namespace` client sender.
pub trait NamespaceClientSender {
    type Transport: ::fidl_next::Transport;

    fn create<___R>(
        &self,
        request: ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, namespace::Create>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNamespaceCreateRequest<'static>,
        >;
}

impl<___T> NamespaceClientSender for ::fidl_next::ClientSender<___T, Namespace>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;

    fn create<___R>(
        &self,
        request: ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, namespace::Create>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireNamespaceCreateRequest<'static>,
        >,
    {
        self.as_untyped()
            .send_two_way(4839678630846501113, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }
}

/// A client handler for the Namespace protocol.
///
/// See [`Namespace`] for more details.
pub trait NamespaceClientHandler<___T: ::fidl_next::Transport> {
    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ClientSender<___T, Namespace>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for Namespace
where
    ___T: ::fidl_next::Transport,
    ___H: NamespaceClientHandler<___T>,

    <namespace::Create 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 `Namespace` server sender.
pub trait NamespaceServerSender {
    type Transport: ::fidl_next::Transport;
}

impl<___T> NamespaceServerSender for ::fidl_next::ServerSender<___T, Namespace>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;
}

/// A server handler for the Namespace protocol.
///
/// See [`Namespace`] for more details.
pub trait NamespaceServerHandler<___T: ::fidl_next::Transport> {
    fn create(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Namespace>,

        request: ::fidl_next::Request<___T, namespace::Create>,

        responder: ::fidl_next::Responder<namespace::Create>,
    );

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Namespace>,
        ordinal: u64,
    ) {
        sender.close();
    }
}

impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for Namespace
where
    ___T: ::fidl_next::Transport,
    ___H: NamespaceServerHandler<___T>,

    <namespace::Create as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => handler.on_unknown_interaction(sender, ordinal),
        }
    }

    fn on_two_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
        responder: ::fidl_next::protocol::Responder,
    ) {
        match ordinal {
            4839678630846501113 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.create(sender, decoded, responder),
                    Err(e) => {
                        sender.close();
                    }
                }
            }

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

pub type RealmOpenExposedDirResponse = ();

/// The wire type corresponding to [`RealmOpenExposedDirResponse`].
pub type WireRealmOpenExposedDirResponse = ();

pub type RealmCreateChildResponse = ();

/// The wire type corresponding to [`RealmCreateChildResponse`].
pub type WireRealmCreateChildResponse = ();

#[derive(Clone, Debug)]
pub struct RealmDestroyChildRequest {
    pub child: ::fidl_next_fuchsia_component_decl::ChildRef,
}

impl ::fidl_next::Encodable for RealmDestroyChildRequest {
    type Encoded = WireRealmDestroyChildRequest<'static>;
}

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

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

            } = out;
        }

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

        Ok(())
    }
}

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

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

            } = out;
        }

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

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

        Ok(())
    }
}

impl<'de> ::fidl_next::FromWire<WireRealmDestroyChildRequest<'de>> for RealmDestroyChildRequest {
    #[inline]
    fn from_wire(wire: WireRealmDestroyChildRequest<'de>) -> Self {
        Self { child: ::fidl_next::FromWire::from_wire(wire.child) }
    }
}

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

/// The wire type corresponding to [`RealmDestroyChildRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireRealmDestroyChildRequest<'de> {
    pub child: ::fidl_next_fuchsia_component_decl::WireChildRef<'de>,
}

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

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

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

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

            } = slot;
        }

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

        Ok(())
    }
}

pub type RealmDestroyChildResponse = ();

/// The wire type corresponding to [`RealmDestroyChildResponse`].
pub type WireRealmDestroyChildResponse = ();

#[derive(Debug)]
pub struct RealmListChildrenRequest {
    pub collection: ::fidl_next_fuchsia_component_decl::CollectionRef,

    pub iter: ::fidl_next::ServerEnd<::fidl_next::fuchsia::zx::Channel, crate::ChildIterator>,
}

impl ::fidl_next::Encodable for RealmListChildrenRequest {
    type Encoded = WireRealmListChildrenRequest<'static>;
}

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

    ___E: ::fidl_next::Encoder,

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

            } = out;
        }

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

impl<'de> ::fidl_next::FromWire<WireRealmListChildrenRequest<'de>> for RealmListChildrenRequest {
    #[inline]
    fn from_wire(wire: WireRealmListChildrenRequest<'de>) -> Self {
        Self {
            collection: ::fidl_next::FromWire::from_wire(wire.collection),

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

/// The wire type corresponding to [`RealmListChildrenRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireRealmListChildrenRequest<'de> {
    pub collection: ::fidl_next_fuchsia_component_decl::WireCollectionRef<'de>,

    pub iter: ::fidl_next::ServerEnd<::fidl_next::fuchsia::WireChannel, crate::ChildIterator>,
}

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

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

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

    ___D: ::fidl_next::Decoder,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut collection,
                mut iter,

            } = slot;
        }

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

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

        Ok(())
    }
}

pub type RealmListChildrenResponse = ();

/// The wire type corresponding to [`RealmListChildrenResponse`].
pub type WireRealmListChildrenResponse = ();

#[derive(Debug)]
pub struct RealmOpenControllerRequest {
    pub child: ::fidl_next_fuchsia_component_decl::ChildRef,

    pub controller: ::fidl_next::ServerEnd<::fidl_next::fuchsia::zx::Channel, crate::Controller>,
}

impl ::fidl_next::Encodable for RealmOpenControllerRequest {
    type Encoded = WireRealmOpenControllerRequest<'static>;
}

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

    ___E: ::fidl_next::Encoder,

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

            } = out;
        }

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

impl<'de> ::fidl_next::FromWire<WireRealmOpenControllerRequest<'de>>
    for RealmOpenControllerRequest
{
    #[inline]
    fn from_wire(wire: WireRealmOpenControllerRequest<'de>) -> Self {
        Self {
            child: ::fidl_next::FromWire::from_wire(wire.child),

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

/// The wire type corresponding to [`RealmOpenControllerRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireRealmOpenControllerRequest<'de> {
    pub child: ::fidl_next_fuchsia_component_decl::WireChildRef<'de>,

    pub controller: ::fidl_next::ServerEnd<::fidl_next::fuchsia::WireChannel, crate::Controller>,
}

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

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

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

    ___D: ::fidl_next::Decoder,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut child,
                mut controller,

            } = slot;
        }

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

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

        Ok(())
    }
}

pub type RealmOpenControllerResponse = ();

/// The wire type corresponding to [`RealmOpenControllerResponse`].
pub type WireRealmOpenControllerResponse = ();

#[derive(Debug)]
pub struct RealmOpenExposedDirRequest {
    pub child: ::fidl_next_fuchsia_component_decl::ChildRef,

    pub exposed_dir: ::fidl_next::ServerEnd<
        ::fidl_next::fuchsia::zx::Channel,
        ::fidl_next_fuchsia_io::Directory,
    >,
}

impl ::fidl_next::Encodable for RealmOpenExposedDirRequest {
    type Encoded = WireRealmOpenExposedDirRequest<'static>;
}

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

    ___E: ::fidl_next::Encoder,

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

            } = out;
        }

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

impl<'de> ::fidl_next::FromWire<WireRealmOpenExposedDirRequest<'de>>
    for RealmOpenExposedDirRequest
{
    #[inline]
    fn from_wire(wire: WireRealmOpenExposedDirRequest<'de>) -> Self {
        Self {
            child: ::fidl_next::FromWire::from_wire(wire.child),

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

/// The wire type corresponding to [`RealmOpenExposedDirRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireRealmOpenExposedDirRequest<'de> {
    pub child: ::fidl_next_fuchsia_component_decl::WireChildRef<'de>,

    pub exposed_dir: ::fidl_next::ServerEnd<
        ::fidl_next::fuchsia::WireChannel,
        ::fidl_next_fuchsia_io::Directory,
    >,
}

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

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

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

    ___D: ::fidl_next::Decoder,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut child,
                mut exposed_dir,

            } = slot;
        }

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

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

        Ok(())
    }
}

#[derive(Debug)]
pub struct RealmCreateChildRequest {
    pub collection: ::fidl_next_fuchsia_component_decl::CollectionRef,

    pub decl: ::fidl_next_fuchsia_component_decl::Child,

    pub args: crate::CreateChildArgs,
}

impl ::fidl_next::Encodable for RealmCreateChildRequest {
    type Encoded = WireRealmCreateChildRequest<'static>;
}

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

    ___E: ::fidl_next::Encoder,

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

            } = out;
        }

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

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

impl<'de> ::fidl_next::FromWire<WireRealmCreateChildRequest<'de>> for RealmCreateChildRequest {
    #[inline]
    fn from_wire(wire: WireRealmCreateChildRequest<'de>) -> Self {
        Self {
            collection: ::fidl_next::FromWire::from_wire(wire.collection),

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

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

/// The wire type corresponding to [`RealmCreateChildRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireRealmCreateChildRequest<'de> {
    pub collection: ::fidl_next_fuchsia_component_decl::WireCollectionRef<'de>,

    pub decl: ::fidl_next_fuchsia_component_decl::WireChild<'de>,

    pub args: crate::WireCreateChildArgs<'de>,
}

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

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

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

    ___D: ::fidl_next::Decoder,

    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut collection,
                mut decl,
                mut args,

            } = slot;
        }

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

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

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

        Ok(())
    }
}

#[derive(Debug)]
pub struct RealmGetResolvedInfoResponse {
    pub resolved_info: ::fidl_next_fuchsia_component_resolution::Component,
}

impl ::fidl_next::Encodable for RealmGetResolvedInfoResponse {
    type Encoded = WireRealmGetResolvedInfoResponse<'static>;
}

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

    ___E: ::fidl_next::Encoder,

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

            } = out;
        }

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

impl<'de> ::fidl_next::FromWire<WireRealmGetResolvedInfoResponse<'de>>
    for RealmGetResolvedInfoResponse
{
    #[inline]
    fn from_wire(wire: WireRealmGetResolvedInfoResponse<'de>) -> Self {
        Self { resolved_info: ::fidl_next::FromWire::from_wire(wire.resolved_info) }
    }
}

/// The wire type corresponding to [`RealmGetResolvedInfoResponse`].
#[derive(Debug)]
#[repr(C)]
pub struct WireRealmGetResolvedInfoResponse<'de> {
    pub resolved_info: ::fidl_next_fuchsia_component_resolution::WireComponent<'de>,
}

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

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

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

    ___D: ::fidl_next::Decoder,

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

            } = slot;
        }

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

        Ok(())
    }
}

#[derive(Debug)]
pub struct RealmGetChildOutputDictionaryRequest {
    pub child: ::fidl_next_fuchsia_component_decl::ChildRef,
}

impl ::fidl_next::Encodable for RealmGetChildOutputDictionaryRequest {
    type Encoded = WireRealmGetChildOutputDictionaryRequest<'static>;
}

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

    ___E: ::fidl_next::Encoder,

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

            } = out;
        }

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

impl<'de> ::fidl_next::FromWire<WireRealmGetChildOutputDictionaryRequest<'de>>
    for RealmGetChildOutputDictionaryRequest
{
    #[inline]
    fn from_wire(wire: WireRealmGetChildOutputDictionaryRequest<'de>) -> Self {
        Self { child: ::fidl_next::FromWire::from_wire(wire.child) }
    }
}

/// The wire type corresponding to [`RealmGetChildOutputDictionaryRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireRealmGetChildOutputDictionaryRequest<'de> {
    pub child: ::fidl_next_fuchsia_component_decl::WireChildRef<'de>,
}

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

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

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

    ___D: ::fidl_next::Decoder,

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

            } = slot;
        }

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

        Ok(())
    }
}

#[derive(Debug)]
#[repr(C)]
pub struct RealmGetChildOutputDictionaryResponse {
    pub dictionary: ::fidl_next_fuchsia_component_sandbox::DictionaryRef,
}

impl ::fidl_next::Encodable for RealmGetChildOutputDictionaryResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
        Self,
        WireRealmGetChildOutputDictionaryResponse,
    > = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true

                && <
                    ::fidl_next_fuchsia_component_sandbox::DictionaryRef as ::fidl_next::Encodable
                >::COPY_OPTIMIZATION.is_enabled()

        )
    };

    type Encoded = WireRealmGetChildOutputDictionaryResponse;
}

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

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

            } = out;
        }

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

impl ::fidl_next::FromWire<WireRealmGetChildOutputDictionaryResponse>
    for RealmGetChildOutputDictionaryResponse
{
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
        WireRealmGetChildOutputDictionaryResponse,
        Self,
    > = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true

                && <
                    ::fidl_next_fuchsia_component_sandbox::DictionaryRef as ::fidl_next::FromWire<::fidl_next_fuchsia_component_sandbox::WireDictionaryRef>
                >::COPY_OPTIMIZATION.is_enabled()

        )
    };

    #[inline]
    fn from_wire(wire: WireRealmGetChildOutputDictionaryResponse) -> Self {
        Self { dictionary: ::fidl_next::FromWire::from_wire(wire.dictionary) }
    }
}

/// The wire type corresponding to [`RealmGetChildOutputDictionaryResponse`].
#[derive(Debug)]
#[repr(C)]
pub struct WireRealmGetChildOutputDictionaryResponse {
    pub dictionary: ::fidl_next_fuchsia_component_sandbox::WireDictionaryRef,
}

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

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireRealmGetChildOutputDictionaryResponse
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?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 {
                mut dictionary,

            } = slot;
        }

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

        Ok(())
    }
}

/// The type corresponding to the Realm protocol.
#[doc = " A protocol used by a component instance to manage its own realm, such as for\n binding to its children.\n\n Requests to this protocol are processed in the order they are received.\n Clients that wish to send requests in parallel should open multiple\n connections.\n\n The component framework provides this service to components that use\n `fuchsia.component.Realm`.\n"]
#[derive(Debug)]
pub struct Realm;

impl ::fidl_next::Discoverable for Realm {
    const PROTOCOL_NAME: &'static str = "fuchsia.component.Realm";
}

pub mod realm {
    pub mod prelude {
        pub use crate::{
            realm, Realm, RealmClientHandler, RealmClientSender, RealmServerHandler,
            RealmServerSender,
        };

        pub use crate::Error;

        pub use crate::RealmCreateChildRequest;

        pub use crate::RealmDestroyChildRequest;

        pub use crate::RealmGetChildOutputDictionaryRequest;

        pub use crate::RealmListChildrenRequest;

        pub use crate::RealmOpenControllerRequest;

        pub use crate::RealmOpenExposedDirRequest;

        pub use crate::RealmCreateChildResponse;

        pub use crate::RealmDestroyChildResponse;

        pub use crate::RealmGetChildOutputDictionaryResponse;

        pub use crate::RealmGetResolvedInfoResponse;

        pub use crate::RealmListChildrenResponse;

        pub use crate::RealmOpenControllerResponse;

        pub use crate::RealmOpenExposedDirResponse;
    }

    pub struct OpenController;

    impl ::fidl_next::Method for OpenController {
        const ORDINAL: u64 = 8165227925828473216;

        type Protocol = crate::Realm;

        type Request = crate::WireRealmOpenControllerRequest<'static>;

        type Response = ::fidl_next::WireResult<
            'static,
            crate::WireRealmOpenControllerResponse,
            crate::WireError,
        >;
    }

    pub struct OpenExposedDir;

    impl ::fidl_next::Method for OpenExposedDir {
        const ORDINAL: u64 = 9194435320863127852;

        type Protocol = crate::Realm;

        type Request = crate::WireRealmOpenExposedDirRequest<'static>;

        type Response = ::fidl_next::WireResult<
            'static,
            crate::WireRealmOpenExposedDirResponse,
            crate::WireError,
        >;
    }

    pub struct CreateChild;

    impl ::fidl_next::Method for CreateChild {
        const ORDINAL: u64 = 4892190024503489888;

        type Protocol = crate::Realm;

        type Request = crate::WireRealmCreateChildRequest<'static>;

        type Response =
            ::fidl_next::WireResult<'static, crate::WireRealmCreateChildResponse, crate::WireError>;
    }

    pub struct DestroyChild;

    impl ::fidl_next::Method for DestroyChild {
        const ORDINAL: u64 = 8203529889988252194;

        type Protocol = crate::Realm;

        type Request = crate::WireRealmDestroyChildRequest<'static>;

        type Response = ::fidl_next::WireResult<
            'static,
            crate::WireRealmDestroyChildResponse,
            crate::WireError,
        >;
    }

    pub struct ListChildren;

    impl ::fidl_next::Method for ListChildren {
        const ORDINAL: u64 = 7532454435519185057;

        type Protocol = crate::Realm;

        type Request = crate::WireRealmListChildrenRequest<'static>;

        type Response = ::fidl_next::WireResult<
            'static,
            crate::WireRealmListChildrenResponse,
            crate::WireError,
        >;
    }

    pub struct GetResolvedInfo;

    impl ::fidl_next::Method for GetResolvedInfo {
        const ORDINAL: u64 = 8308987710372188322;

        type Protocol = crate::Realm;

        type Request = ();

        type Response = ::fidl_next::WireResult<
            'static,
            crate::WireRealmGetResolvedInfoResponse<'static>,
            crate::WireError,
        >;
    }

    pub struct GetChildOutputDictionary;

    impl ::fidl_next::Method for GetChildOutputDictionary {
        const ORDINAL: u64 = 4781081784078915088;

        type Protocol = crate::Realm;

        type Request = crate::WireRealmGetChildOutputDictionaryRequest<'static>;

        type Response = ::fidl_next::WireResult<
            'static,
            crate::WireRealmGetChildOutputDictionaryResponse,
            crate::WireError,
        >;
    }
}

/// A helper trait for the `Realm` client sender.
pub trait RealmClientSender {
    type Transport: ::fidl_next::Transport;

    #[doc = " Operate on a child component. See documentation for [`Controller`].\n\n Errors:\n - `INVALID_ARGUMENTS`: `child` is not a valid child reference.\n - `INSTANCE_NOT_FOUND`: `child` does not exist.\n - `INSTANCE_DIED`: This realm no longer exists.\n"]
    fn open_controller<___R>(
        &self,
        request: ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, realm::OpenController>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireRealmOpenControllerRequest<'static>,
        >;

    #[doc = " Opens the exposed directory of a child component instance. When this\n function successfully returns, `exposed_dir` is bound to a directory\n that contains the capabilities which the child exposed to its realm\n via `ComponentDecl.exposes` (specified via \"expose\" declarations in\n the component\'s manifest). The child component will not start as a\n result of this call. Instead, starting will occur iff the parent binds\n to one of the capabilities contained within `exposed_dir`.\n\n `exposed_dir` is open as long as `child` exists.\n\n Errors:\n - `INVALID_ARGUMENTS`: `child` is not a valid child reference.\n - `INSTANCE_NOT_FOUND`: `child` does not exist.\n - `INSTANCE_CANNOT_RESOLVE`: `child`\'s component declaration failed to resolve.\n - `INSTANCE_DIED`: This realm no longer exists.\n"]
    fn open_exposed_dir<___R>(
        &self,
        request: ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, realm::OpenExposedDir>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireRealmOpenExposedDirRequest<'static>,
        >;

    #[doc = " Creates a child component instance dynamically. When this function\n returns successfully, the instance exists, but it may not be running.\n\n The environment of the child instance is determined by the environment\n of the collection. `decl` must not set `environment`.\n\n If `decl.startup == EAGER`, or `collection.durability == SINGLE_RUN`,\n [CreateChild] will start the component and return once the component is\n started. Otherwise, [CreateChild] will return immediately after creating\n the component and will not start or resolve it.\n\n Errors:\n - `INVALID_ARGUMENTS`: `collection` is not a valid reference or `child`\n   is not a valid declaration.\n - `COLLECTION_NOT_FOUND`: `collection` does not exist.\n - `INSTANCE_ALREADY_EXISTS`: `decl.name` already exists in `collection`.\n - `INSTANCE_CANNOT_RESOLVE`: `child`\'s component declaration failed to resolve\n   in a `SingleRun` collection.\n - `NO_SPACE`: Could not allocate storage for the new instance.\n - `INSTANCE_DIED`: This realm no longer exists.\n"]
    fn create_child<___R>(
        &self,
        request: ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, realm::CreateChild>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireRealmCreateChildRequest<'static>,
        >;

    #[doc = " Destroys a dynamically-created component instance. When this function\n returns, the instance is destroyed and has stopped running.  However,\n cleanup of the component\'s resources (such as its isolated storage) may\n happen in the background after this function returns.\n\n Errors:\n - `INVALID_ARGUMENTS`: `child` is not a valid reference or does not refer\n   to a dynamic instance.\n - `INSTANCE_NOT_FOUND`: `child` does not exist.\n - `COLLECTION_NOT_FOUND`: `collection` does not exist.\n - `INSTANCE_DIED`: This realm no longer exists.\n"]
    fn destroy_child<___R>(
        &self,
        request: ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, realm::DestroyChild>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireRealmDestroyChildRequest<'static>,
        >;

    #[doc = " Returns an iterator that lists all instances in a collection.\n\n NOTE: The results are not guaranteed to be consistent. Instances may be\n created or destroyed while the iterator is live, but those changes\n won\'t be observed by the iterator after this method returns.\n\n Errors:\n - `INVALID_ARGUMENTS`: `collection` is not a valid reference or `iter`\n does not have `ZX_RIGHT_WAIT`.\n - `COLLECTION_NOT_FOUND`: `collection` does not exist.\n - `INSTANCE_DIED`: This realm no longer exists.\n - If `iter` does not have standard channel rights, this function may\n   return `ACCESS_DENIED` or component manager may close `iter`.\n"]
    fn list_children<___R>(
        &self,
        request: ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, realm::ListChildren>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireRealmListChildrenRequest<'static>,
        >;

    #[doc = " Returns the set of information that was given to the component framework\n by this component\'s resolver.\n"]
    fn get_resolved_info(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, realm::GetResolvedInfo>,
        ::fidl_next::EncodeError,
    >;

    fn get_child_output_dictionary<___R>(
        &self,
        request: ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, realm::GetChildOutputDictionary>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireRealmGetChildOutputDictionaryRequest<'static>,
        >;
}

impl<___T> RealmClientSender for ::fidl_next::ClientSender<___T, Realm>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;

    #[doc = " Operate on a child component. See documentation for [`Controller`].\n\n Errors:\n - `INVALID_ARGUMENTS`: `child` is not a valid child reference.\n - `INSTANCE_NOT_FOUND`: `child` does not exist.\n - `INSTANCE_DIED`: This realm no longer exists.\n"]
    fn open_controller<___R>(
        &self,
        request: ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, realm::OpenController>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireRealmOpenControllerRequest<'static>,
        >,
    {
        self.as_untyped()
            .send_two_way(8165227925828473216, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Opens the exposed directory of a child component instance. When this\n function successfully returns, `exposed_dir` is bound to a directory\n that contains the capabilities which the child exposed to its realm\n via `ComponentDecl.exposes` (specified via \"expose\" declarations in\n the component\'s manifest). The child component will not start as a\n result of this call. Instead, starting will occur iff the parent binds\n to one of the capabilities contained within `exposed_dir`.\n\n `exposed_dir` is open as long as `child` exists.\n\n Errors:\n - `INVALID_ARGUMENTS`: `child` is not a valid child reference.\n - `INSTANCE_NOT_FOUND`: `child` does not exist.\n - `INSTANCE_CANNOT_RESOLVE`: `child`\'s component declaration failed to resolve.\n - `INSTANCE_DIED`: This realm no longer exists.\n"]
    fn open_exposed_dir<___R>(
        &self,
        request: ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, realm::OpenExposedDir>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireRealmOpenExposedDirRequest<'static>,
        >,
    {
        self.as_untyped()
            .send_two_way(9194435320863127852, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Creates a child component instance dynamically. When this function\n returns successfully, the instance exists, but it may not be running.\n\n The environment of the child instance is determined by the environment\n of the collection. `decl` must not set `environment`.\n\n If `decl.startup == EAGER`, or `collection.durability == SINGLE_RUN`,\n [CreateChild] will start the component and return once the component is\n started. Otherwise, [CreateChild] will return immediately after creating\n the component and will not start or resolve it.\n\n Errors:\n - `INVALID_ARGUMENTS`: `collection` is not a valid reference or `child`\n   is not a valid declaration.\n - `COLLECTION_NOT_FOUND`: `collection` does not exist.\n - `INSTANCE_ALREADY_EXISTS`: `decl.name` already exists in `collection`.\n - `INSTANCE_CANNOT_RESOLVE`: `child`\'s component declaration failed to resolve\n   in a `SingleRun` collection.\n - `NO_SPACE`: Could not allocate storage for the new instance.\n - `INSTANCE_DIED`: This realm no longer exists.\n"]
    fn create_child<___R>(
        &self,
        request: ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, realm::CreateChild>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireRealmCreateChildRequest<'static>,
        >,
    {
        self.as_untyped()
            .send_two_way(4892190024503489888, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Destroys a dynamically-created component instance. When this function\n returns, the instance is destroyed and has stopped running.  However,\n cleanup of the component\'s resources (such as its isolated storage) may\n happen in the background after this function returns.\n\n Errors:\n - `INVALID_ARGUMENTS`: `child` is not a valid reference or does not refer\n   to a dynamic instance.\n - `INSTANCE_NOT_FOUND`: `child` does not exist.\n - `COLLECTION_NOT_FOUND`: `collection` does not exist.\n - `INSTANCE_DIED`: This realm no longer exists.\n"]
    fn destroy_child<___R>(
        &self,
        request: ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, realm::DestroyChild>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireRealmDestroyChildRequest<'static>,
        >,
    {
        self.as_untyped()
            .send_two_way(8203529889988252194, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Returns an iterator that lists all instances in a collection.\n\n NOTE: The results are not guaranteed to be consistent. Instances may be\n created or destroyed while the iterator is live, but those changes\n won\'t be observed by the iterator after this method returns.\n\n Errors:\n - `INVALID_ARGUMENTS`: `collection` is not a valid reference or `iter`\n does not have `ZX_RIGHT_WAIT`.\n - `COLLECTION_NOT_FOUND`: `collection` does not exist.\n - `INSTANCE_DIED`: This realm no longer exists.\n - If `iter` does not have standard channel rights, this function may\n   return `ACCESS_DENIED` or component manager may close `iter`.\n"]
    fn list_children<___R>(
        &self,
        request: ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, realm::ListChildren>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireRealmListChildrenRequest<'static>,
        >,
    {
        self.as_untyped()
            .send_two_way(7532454435519185057, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Returns the set of information that was given to the component framework\n by this component\'s resolver.\n"]
    fn get_resolved_info(
        &self,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, realm::GetResolvedInfo>,
        ::fidl_next::EncodeError,
    > {
        self.as_untyped()
            .send_two_way(8308987710372188322, ())
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    fn get_child_output_dictionary<___R>(
        &self,
        request: ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, realm::GetChildOutputDictionary>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireRealmGetChildOutputDictionaryRequest<'static>,
        >,
    {
        self.as_untyped()
            .send_two_way(4781081784078915088, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }
}

/// A client handler for the Realm protocol.
///
/// See [`Realm`] for more details.
pub trait RealmClientHandler<___T: ::fidl_next::Transport> {}

impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for Realm
where
    ___T: ::fidl_next::Transport,
    ___H: RealmClientHandler<___T>,

    <realm::OpenController as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <realm::OpenExposedDir as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <realm::CreateChild as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <realm::DestroyChild as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <realm::ListChildren as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <realm::GetResolvedInfo as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <realm::GetChildOutputDictionary 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 => {
                sender.close();
            }
        }
    }
}

/// A helper trait for the `Realm` server sender.
pub trait RealmServerSender {
    type Transport: ::fidl_next::Transport;
}

impl<___T> RealmServerSender for ::fidl_next::ServerSender<___T, Realm>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;
}

/// A server handler for the Realm protocol.
///
/// See [`Realm`] for more details.
pub trait RealmServerHandler<___T: ::fidl_next::Transport> {
    #[doc = " Operate on a child component. See documentation for [`Controller`].\n\n Errors:\n - `INVALID_ARGUMENTS`: `child` is not a valid child reference.\n - `INSTANCE_NOT_FOUND`: `child` does not exist.\n - `INSTANCE_DIED`: This realm no longer exists.\n"]
    fn open_controller(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Realm>,

        request: ::fidl_next::Request<___T, realm::OpenController>,

        responder: ::fidl_next::Responder<realm::OpenController>,
    );

    #[doc = " Opens the exposed directory of a child component instance. When this\n function successfully returns, `exposed_dir` is bound to a directory\n that contains the capabilities which the child exposed to its realm\n via `ComponentDecl.exposes` (specified via \"expose\" declarations in\n the component\'s manifest). The child component will not start as a\n result of this call. Instead, starting will occur iff the parent binds\n to one of the capabilities contained within `exposed_dir`.\n\n `exposed_dir` is open as long as `child` exists.\n\n Errors:\n - `INVALID_ARGUMENTS`: `child` is not a valid child reference.\n - `INSTANCE_NOT_FOUND`: `child` does not exist.\n - `INSTANCE_CANNOT_RESOLVE`: `child`\'s component declaration failed to resolve.\n - `INSTANCE_DIED`: This realm no longer exists.\n"]
    fn open_exposed_dir(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Realm>,

        request: ::fidl_next::Request<___T, realm::OpenExposedDir>,

        responder: ::fidl_next::Responder<realm::OpenExposedDir>,
    );

    #[doc = " Creates a child component instance dynamically. When this function\n returns successfully, the instance exists, but it may not be running.\n\n The environment of the child instance is determined by the environment\n of the collection. `decl` must not set `environment`.\n\n If `decl.startup == EAGER`, or `collection.durability == SINGLE_RUN`,\n [CreateChild] will start the component and return once the component is\n started. Otherwise, [CreateChild] will return immediately after creating\n the component and will not start or resolve it.\n\n Errors:\n - `INVALID_ARGUMENTS`: `collection` is not a valid reference or `child`\n   is not a valid declaration.\n - `COLLECTION_NOT_FOUND`: `collection` does not exist.\n - `INSTANCE_ALREADY_EXISTS`: `decl.name` already exists in `collection`.\n - `INSTANCE_CANNOT_RESOLVE`: `child`\'s component declaration failed to resolve\n   in a `SingleRun` collection.\n - `NO_SPACE`: Could not allocate storage for the new instance.\n - `INSTANCE_DIED`: This realm no longer exists.\n"]
    fn create_child(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Realm>,

        request: ::fidl_next::Request<___T, realm::CreateChild>,

        responder: ::fidl_next::Responder<realm::CreateChild>,
    );

    #[doc = " Destroys a dynamically-created component instance. When this function\n returns, the instance is destroyed and has stopped running.  However,\n cleanup of the component\'s resources (such as its isolated storage) may\n happen in the background after this function returns.\n\n Errors:\n - `INVALID_ARGUMENTS`: `child` is not a valid reference or does not refer\n   to a dynamic instance.\n - `INSTANCE_NOT_FOUND`: `child` does not exist.\n - `COLLECTION_NOT_FOUND`: `collection` does not exist.\n - `INSTANCE_DIED`: This realm no longer exists.\n"]
    fn destroy_child(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Realm>,

        request: ::fidl_next::Request<___T, realm::DestroyChild>,

        responder: ::fidl_next::Responder<realm::DestroyChild>,
    );

    #[doc = " Returns an iterator that lists all instances in a collection.\n\n NOTE: The results are not guaranteed to be consistent. Instances may be\n created or destroyed while the iterator is live, but those changes\n won\'t be observed by the iterator after this method returns.\n\n Errors:\n - `INVALID_ARGUMENTS`: `collection` is not a valid reference or `iter`\n does not have `ZX_RIGHT_WAIT`.\n - `COLLECTION_NOT_FOUND`: `collection` does not exist.\n - `INSTANCE_DIED`: This realm no longer exists.\n - If `iter` does not have standard channel rights, this function may\n   return `ACCESS_DENIED` or component manager may close `iter`.\n"]
    fn list_children(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Realm>,

        request: ::fidl_next::Request<___T, realm::ListChildren>,

        responder: ::fidl_next::Responder<realm::ListChildren>,
    );

    #[doc = " Returns the set of information that was given to the component framework\n by this component\'s resolver.\n"]
    fn get_resolved_info(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Realm>,

        responder: ::fidl_next::Responder<realm::GetResolvedInfo>,
    );

    fn get_child_output_dictionary(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Realm>,

        request: ::fidl_next::Request<___T, realm::GetChildOutputDictionary>,

        responder: ::fidl_next::Responder<realm::GetChildOutputDictionary>,
    );
}

impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for Realm
where
    ___T: ::fidl_next::Transport,
    ___H: RealmServerHandler<___T>,

    <realm::OpenController as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <realm::OpenExposedDir as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <realm::CreateChild as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <realm::DestroyChild as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <realm::ListChildren as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <realm::GetChildOutputDictionary as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => {
                sender.close();
            }
        }
    }

    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 {
            8165227925828473216 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.open_controller(sender, decoded, responder),
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            9194435320863127852 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.open_exposed_dir(sender, decoded, responder),
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            4892190024503489888 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.create_child(sender, decoded, responder),
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            8203529889988252194 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.destroy_child(sender, decoded, responder),
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            7532454435519185057 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.list_children(sender, decoded, responder),
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            8308987710372188322 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.get_resolved_info(sender, responder);
            }

            4781081784078915088 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.get_child_output_dictionary(sender, decoded, responder),
                    Err(e) => {
                        sender.close();
                    }
                }
            }

            ordinal => {
                sender.close();
            }
        }
    }
}

pub type ChildName = String;

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

pub type UrlScheme = String;

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

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

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client sender over `zx::Channel` for the `Binder`
    /// protocol.
    pub type BinderProxy =
        ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::Binder>;

    impl ::core::convert::From<crate::Binder> for ::fidl_fuchsia_component::BinderMarker {
        #[inline]
        fn from(_: crate::Binder) -> Self {
            Self
        }
    }

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client sender over `zx::Channel` for the `ChildIterator`
    /// protocol.
    pub type ChildIteratorProxy =
        ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::ChildIterator>;

    impl ::core::convert::From<crate::ChildIterator> for ::fidl_fuchsia_component::ChildIteratorMarker {
        #[inline]
        fn from(_: crate::ChildIterator) -> Self {
            Self
        }
    }

    impl ::core::convert::From<crate::Error> for ::fidl_fuchsia_component::Error {
        #[inline]
        fn from(from: crate::Error) -> Self {
            match crate::Error::from(from) {
                crate::Error::Internal => Self::Internal,

                crate::Error::InvalidArguments => Self::InvalidArguments,

                crate::Error::Unsupported => Self::Unsupported,

                crate::Error::AccessDenied => Self::AccessDenied,

                crate::Error::InstanceNotFound => Self::InstanceNotFound,

                crate::Error::InstanceAlreadyExists => Self::InstanceAlreadyExists,

                crate::Error::InstanceCannotStart => Self::InstanceCannotStart,

                crate::Error::InstanceCannotResolve => Self::InstanceCannotResolve,

                crate::Error::CollectionNotFound => Self::CollectionNotFound,

                crate::Error::ResourceUnavailable => Self::ResourceUnavailable,

                crate::Error::InstanceDied => Self::InstanceDied,

                crate::Error::ResourceNotFound => Self::ResourceNotFound,

                crate::Error::InstanceCannotUnresolve => Self::InstanceCannotUnresolve,

                crate::Error::InstanceAlreadyStarted => Self::InstanceAlreadyStarted,

                crate::Error::UnknownOrdinal_(value) => {
                    Self::__SourceBreaking { unknown_ordinal: value }
                }
            }
        }
    }

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client sender over `zx::Channel` for the `Controller`
    /// protocol.
    pub type ControllerProxy =
        ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::Controller>;

    impl ::core::convert::From<crate::Controller> for ::fidl_fuchsia_component::ControllerMarker {
        #[inline]
        fn from(_: crate::Controller) -> Self {
            Self
        }
    }

    impl ::core::convert::From<crate::EventType> for ::fidl_fuchsia_component::EventType {
        #[inline]
        fn from(from: crate::EventType) -> Self {
            match crate::EventType::from(from) {
                crate::EventType::CapabilityRequested => Self::CapabilityRequested,

                crate::EventType::DirectoryReady => Self::DirectoryReady,

                crate::EventType::Discovered => Self::Discovered,

                crate::EventType::Destroyed => Self::Destroyed,

                crate::EventType::Resolved => Self::Resolved,

                crate::EventType::Started => Self::Started,

                crate::EventType::Stopped => Self::Stopped,

                crate::EventType::DebugStarted => Self::DebugStarted,

                crate::EventType::Unresolved => Self::Unresolved,
            }
        }
    }

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client sender over `zx::Channel` for the `EventStream`
    /// protocol.
    pub type EventStreamProxy =
        ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::EventStream>;

    impl ::core::convert::From<crate::EventStream> for ::fidl_fuchsia_component::EventStreamMarker {
        #[inline]
        fn from(_: crate::EventStream) -> Self {
            Self
        }
    }

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client sender over `zx::Channel` for the `ExecutionController`
    /// protocol.
    pub type ExecutionControllerProxy =
        ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::ExecutionController>;

    impl ::core::convert::From<crate::ExecutionController>
        for ::fidl_fuchsia_component::ExecutionControllerMarker
    {
        #[inline]
        fn from(_: crate::ExecutionController) -> Self {
            Self
        }
    }

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client sender over `zx::Channel` for the `Introspector`
    /// protocol.
    pub type IntrospectorProxy =
        ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::Introspector>;

    impl ::core::convert::From<crate::Introspector> for ::fidl_fuchsia_component::IntrospectorMarker {
        #[inline]
        fn from(_: crate::Introspector) -> Self {
            Self
        }
    }

    impl ::core::convert::From<crate::NamespaceError> for ::fidl_fuchsia_component::NamespaceError {
        #[inline]
        fn from(from: crate::NamespaceError) -> Self {
            match crate::NamespaceError::from(from) {
                crate::NamespaceError::Shadow => Self::Shadow,

                crate::NamespaceError::Duplicate => Self::Duplicate,

                crate::NamespaceError::Conversion => Self::Conversion,

                crate::NamespaceError::BadEntry => Self::BadEntry,

                crate::NamespaceError::DictionaryRead => Self::DictionaryRead,

                crate::NamespaceError::UnknownOrdinal_(value) => {
                    Self::__SourceBreaking { unknown_ordinal: value }
                }
            }
        }
    }

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client sender over `zx::Channel` for the `Namespace`
    /// protocol.
    pub type NamespaceProxy =
        ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::Namespace>;

    impl ::core::convert::From<crate::Namespace> for ::fidl_fuchsia_component::NamespaceMarker {
        #[inline]
        fn from(_: crate::Namespace) -> Self {
            Self
        }
    }

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client sender over `zx::Channel` for the `Realm`
    /// protocol.
    pub type RealmProxy =
        ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::Realm>;

    impl ::core::convert::From<crate::Realm> for ::fidl_fuchsia_component::RealmMarker {
        #[inline]
        fn from(_: crate::Realm) -> Self {
            Self
        }
    }
}