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

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

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for CapabilityRequestedPayload {
    type Encoded = WireCapabilityRequestedPayload;
}

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

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

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

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

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

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

        Ok(())
    }
}

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

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

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

unsafe impl ::fidl_next::ZeroPadding for WireCapabilityRequestedPayload {
    #[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
where
    ___D: ::fidl_next::Decoder + ?Sized,

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

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

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

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

                    if name.len() > 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 WireCapabilityRequestedPayload {
    pub fn name(&self) -> Option<&::fidl_next::WireString> {
        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 ::core::fmt::Debug for WireCapabilityRequestedPayload {
    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;
}

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

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

            } = out;
        }

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireChildIteratorNextResponse> for ChildIteratorNextResponse {
    #[inline]
    fn take_from(from: &WireChildIteratorNextResponse) -> Self {
        Self { children: ::fidl_next::TakeFrom::take_from(&from.children) }
    }
}

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

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

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

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

    #[inline]
    fn take_from(from: &WireControllerIsStartedResponse) -> Self {
        Self { is_started: ::fidl_next::TakeFrom::take_from(&from.is_started) }
    }
}

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

unsafe impl ::fidl_next::ZeroPadding for 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;
}

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

/// 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::ZeroPadding for WireError {
    #[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)]
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.path.is_some() {
            return 1;
        }

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

        0
    }
}

impl ::fidl_next::Encodable for NamespaceEntry {
    type Encoded = WireNamespaceEntry;
}

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

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

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

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

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

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

unsafe impl ::fidl_next::ZeroPadding for WireNamespaceEntry {
    #[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
where
    ___D: ::fidl_next::Decoder + ?Sized,

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

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

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

                    let 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 WireNamespaceEntry {
    pub fn path(&self) -> Option<&::fidl_next::WireString> {
        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 ::core::fmt::Debug for WireNamespaceEntry {
    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)]
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.numbered_handles.is_some() {
            return 1;
        }

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

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

        0
    }
}

impl ::fidl_next::Encodable for StartChildArgs {
    type Encoded = WireStartChildArgs;
}

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

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

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

                2 => {
                    if let Some(namespace_entries) = &mut self.namespace_entries {
                        ::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) = &mut self.numbered_handles {
                        ::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 ::fidl_next::TakeFrom<WireStartChildArgs> for StartChildArgs {
    #[inline]
    fn take_from(from: &WireStartChildArgs) -> Self {
        Self {
            numbered_handles: from.numbered_handles().map(::fidl_next::TakeFrom::take_from),

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

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

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

unsafe impl ::fidl_next::ZeroPadding for WireStartChildArgs {
    #[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
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<::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<crate::WireNamespaceEntry>,
                    >(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 WireStartChildArgs {
    pub fn numbered_handles(
        &self,
    ) -> Option<&::fidl_next::WireVector<::fidl_next_fuchsia_process::WireHandleInfo>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn namespace_entries(&self) -> Option<&::fidl_next::WireVector<crate::WireNamespaceEntry>> {
        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 ::core::fmt::Debug for WireStartChildArgs {
    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;
}

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

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

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

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

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

unsafe impl ::fidl_next::ZeroPadding for WireControllerStartRequest {
    #[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
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> = 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(
        &mut 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(&mut self.dictionary, encoder, dictionary)?;

        Ok(())
    }
}

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

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

        Ok(())
    }
}

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

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

        )
    };

    #[inline]
    fn take_from(from: &WireControllerGetExposedDictionaryResponse) -> Self {
        Self { dictionary: ::fidl_next::TakeFrom::take_from(&from.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::ZeroPadding for 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;

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

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

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

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

            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)]
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.numbered_handles.is_some() {
            return 1;
        }

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for CreateChildArgs {
    type Encoded = WireCreateChildArgs;
}

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

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

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

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

                2 => {
                    if let Some(dynamic_offers) = &mut self.dynamic_offers {
                        ::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) = &mut self.numbered_handles {
                        ::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 ::fidl_next::TakeFrom<WireCreateChildArgs> for CreateChildArgs {
    #[inline]
    fn take_from(from: &WireCreateChildArgs) -> Self {
        Self {
            numbered_handles: from.numbered_handles().map(::fidl_next::TakeFrom::take_from),

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

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

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

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

unsafe impl ::fidl_next::ZeroPadding for WireCreateChildArgs {
    #[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
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<::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<::fidl_next_fuchsia_component_decl::WireOffer>,
                    >(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 WireCreateChildArgs {
    pub fn numbered_handles(
        &self,
    ) -> Option<&::fidl_next::WireVector<::fidl_next_fuchsia_process::WireHandleInfo>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn dynamic_offers(
        &self,
    ) -> Option<&::fidl_next::WireVector<::fidl_next_fuchsia_component_decl::WireOffer>> {
        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 ::core::fmt::Debug for WireCreateChildArgs {
    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)]
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.runtime_dir.is_some() {
            return 1;
        }

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

        0
    }
}

impl ::fidl_next::Encodable for DebugStartedPayload {
    type Encoded = WireDebugStartedPayload;
}

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

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

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

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

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

unsafe impl ::fidl_next::ZeroPadding for WireDebugStartedPayload {
    #[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
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 WireDebugStartedPayload {
    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 ::core::fmt::Debug for WireDebugStartedPayload {
    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)]
pub struct DestroyedPayload {}

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

impl ::fidl_next::Encodable for DestroyedPayload {
    type Encoded = WireDestroyedPayload;
}

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

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

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

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

        Ok(())
    }
}

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

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

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

impl ::core::fmt::Debug for WireDestroyedPayload {
    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)]
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.name.is_some() {
            return 1;
        }

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

        0
    }
}

impl ::fidl_next::Encodable for DirectoryReadyPayload {
    type Encoded = WireDirectoryReadyPayload;
}

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

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

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

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

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

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

        Ok(())
    }
}

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

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

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

unsafe impl ::fidl_next::ZeroPadding for WireDirectoryReadyPayload {
    #[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
where
    ___D: ::fidl_next::Decoder + ?Sized,

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

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

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

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

                    if name.len() > 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 WireDirectoryReadyPayload {
    pub fn name(&self) -> Option<&::fidl_next::WireString> {
        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 ::core::fmt::Debug for WireDirectoryReadyPayload {
    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)]
pub struct DiscoveredPayload {}

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

impl ::fidl_next::Encodable for DiscoveredPayload {
    type Encoded = WireDiscoveredPayload;
}

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

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

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

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

        Ok(())
    }
}

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

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

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

impl ::core::fmt::Debug for WireDiscoveredPayload {
    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)]
pub struct PurgedPayload {}

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

impl ::fidl_next::Encodable for PurgedPayload {
    type Encoded = WirePurgedPayload;
}

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

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

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

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

        Ok(())
    }
}

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

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

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

impl ::core::fmt::Debug for WirePurgedPayload {
    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)]
pub struct ResolvedPayload {}

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

impl ::fidl_next::Encodable for ResolvedPayload {
    type Encoded = WireResolvedPayload;
}

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

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

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

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

        Ok(())
    }
}

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

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

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

impl ::core::fmt::Debug for WireResolvedPayload {
    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)]
pub struct StartedPayload {}

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

impl ::fidl_next::Encodable for StartedPayload {
    type Encoded = WireStartedPayload;
}

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

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

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

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

        Ok(())
    }
}

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

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

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

impl ::core::fmt::Debug for WireStartedPayload {
    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)]
pub struct UnresolvedPayload {}

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

impl ::fidl_next::Encodable for UnresolvedPayload {
    type Encoded = WireUnresolvedPayload;
}

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

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

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

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

        Ok(())
    }
}

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

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

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

impl ::core::fmt::Debug for WireUnresolvedPayload {
    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)]
pub struct StoppedPayload {
    pub status: Option<i32>,

    pub exit_code: Option<i64>,
}

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

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

        0
    }
}

impl ::fidl_next::Encodable for StoppedPayload {
    type Encoded = WireStoppedPayload;
}

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

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

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

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

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

unsafe impl ::fidl_next::ZeroPadding for WireStoppedPayload {
    #[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
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 WireStoppedPayload {
    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 ::core::fmt::Debug for WireStoppedPayload {
    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;
}

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

/// 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::ZeroPadding for WireEventType {
    #[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)]
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.event_type.is_some() {
            return 1;
        }

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for EventHeader {
    type Encoded = WireEventHeader;
}

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

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

        for i in 1..=max_ord {
            match i {
                4 => {
                    if let Some(timestamp) = &mut 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) = &mut 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) = &mut 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) = &mut 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 ::fidl_next::TakeFrom<WireEventHeader> for EventHeader {
    #[inline]
    fn take_from(from: &WireEventHeader) -> Self {
        Self {
            event_type: from.event_type().map(::fidl_next::TakeFrom::take_from),

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

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

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

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

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

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

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

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(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireEventPayload { raw } = 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 Box<EventPayload> {
    type EncodedOption = WireOptionalEventPayload;
}

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

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireEventPayload> for EventPayload {
    #[inline]
    fn take_from(from: &WireEventPayload) -> Self {
        match from.raw.ordinal() {
            1 => Self::CapabilityRequested(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<crate::WireCapabilityRequestedPayload>()
            })),

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

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

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

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

            6 => Self::Resolved(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<crate::WireResolvedPayload>()
            })),

            7 => Self::Started(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<crate::WireStartedPayload>()
            })),

            8 => Self::Stopped(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<crate::WireStoppedPayload>()
            })),

            9 => Self::DebugStarted(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<crate::WireDebugStartedPayload>()
            })),

            10 => Self::Unresolved(::fidl_next::TakeFrom::take_from(unsafe {
                from.raw.get().deref_unchecked::<crate::WireUnresolvedPayload>()
            })),

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

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

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

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

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

        Purged(&'union crate::WirePurgedPayload),

        DirectoryReady(&'union crate::WireDirectoryReadyPayload),

        Discovered(&'union crate::WireDiscoveredPayload),

        Destroyed(&'union crate::WireDestroyedPayload),

        Resolved(&'union crate::WireResolvedPayload),

        Started(&'union crate::WireStartedPayload),

        Stopped(&'union crate::WireStoppedPayload),

        DebugStarted(&'union crate::WireDebugStartedPayload),

        Unresolved(&'union crate::WireUnresolvedPayload),

        UnknownOrdinal_(u64),
    }
}

impl WireEventPayload {
    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
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 } = slot.as_mut());
        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
            1 => {
                ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireCapabilityRequestedPayload>(
                    raw, decoder,
                )?
            }

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

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

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

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

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

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

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

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

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

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

        Ok(())
    }
}

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

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

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptionalEventPayload
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 } = slot.as_mut());
        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
            1 => {
                ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireCapabilityRequestedPayload>(
                    raw, decoder,
                )?
            }

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

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

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

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

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

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

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

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

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

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

        Ok(())
    }
}

impl ::core::fmt::Debug for WireOptionalEventPayload {
    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)]
pub struct Event {
    pub header: Option<crate::EventHeader>,

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for Event {
    type Encoded = WireEvent;
}

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

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

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

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

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

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

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

                    Ok(())
                }

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

                    Ok(())
                }

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

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

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

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<EventStreamGetNextResponse> {
    type EncodedOption = ::fidl_next::WireBox<WireEventStreamGetNextResponse>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireEventStreamGetNextResponse> for EventStreamGetNextResponse {
    #[inline]
    fn take_from(from: &WireEventStreamGetNextResponse) -> Self {
        Self { events: ::fidl_next::TakeFrom::take_from(&from.events) }
    }
}

/// The wire type corresponding to [`EventStreamGetNextResponse`].
#[derive(Debug)]
#[repr(C)]
pub struct WireEventStreamGetNextResponse {
    pub events: ::fidl_next::WireVector<crate::WireEvent>,
}

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireEventStreamGetNextResponse
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 = "event_stream";
}

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

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

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

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

            } = out;
        }

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<ExecutionControllerOnStopRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireExecutionControllerOnStopRequest>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireExecutionControllerOnStopRequest>
    for ExecutionControllerOnStopRequest
{
    #[inline]
    fn take_from(from: &WireExecutionControllerOnStopRequest) -> Self {
        Self { stopped_payload: ::fidl_next::TakeFrom::take_from(&from.stopped_payload) }
    }
}

/// The wire type corresponding to [`ExecutionControllerOnStopRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireExecutionControllerOnStopRequest {
    pub stopped_payload: crate::WireStoppedPayload,
}

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

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

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

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

        message: ::fidl_next::ResponseBuffer<___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 => {
                let buffer = ::fidl_next::ResponseBuffer::from_untyped(buffer);
                handler.on_stop(sender, buffer);
            }

            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: &mut ___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: &mut ___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> = 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(
        &mut 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(&mut self.component_instance, encoder, component_instance)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<IntrospectorGetMonikerRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireIntrospectorGetMonikerRequest>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireIntrospectorGetMonikerRequest> for IntrospectorGetMonikerRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <::fidl_next::fuchsia::zx::Handle as ::fidl_next::Encodable>::COPY_OPTIMIZATION
                .is_enabled(),
        )
    };

    #[inline]
    fn take_from(from: &WireIntrospectorGetMonikerRequest) -> Self {
        Self { component_instance: ::fidl_next::TakeFrom::take_from(&from.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::ZeroPadding for 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;
}

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

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

            } = out;
        }

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<IntrospectorGetMonikerResponse> {
    type EncodedOption = ::fidl_next::WireBox<WireIntrospectorGetMonikerResponse>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireIntrospectorGetMonikerResponse> for IntrospectorGetMonikerResponse {
    #[inline]
    fn take_from(from: &WireIntrospectorGetMonikerResponse) -> Self {
        Self { moniker: ::fidl_next::TakeFrom::take_from(&from.moniker) }
    }
}

/// The wire type corresponding to [`IntrospectorGetMonikerResponse`].
#[derive(Debug)]
#[repr(C)]
pub struct WireIntrospectorGetMonikerResponse {
    pub moniker: ::fidl_next::WireString,
}

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireIntrospectorGetMonikerResponse
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 = "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<
            crate::WireIntrospectorGetMonikerResponse,
            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: &mut ___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: &mut ___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::RequestBuffer<___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>,

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

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

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

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<NamespaceInputEntry> {
    type EncodedOption = ::fidl_next::WireBox<WireNamespaceInputEntry>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireNamespaceInputEntry> for NamespaceInputEntry {
    #[inline]
    fn take_from(from: &WireNamespaceInputEntry) -> Self {
        Self {
            path: ::fidl_next::TakeFrom::take_from(&from.path),

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

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

    pub dictionary: ::fidl_next::ClientEnd<
        ::fidl_next::fuchsia::WireChannel,
        ::fidl_next_fuchsia_component_sandbox::Dictionary,
    >,
}

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<NamespaceCreateRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireNamespaceCreateRequest>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireNamespaceCreateRequest> for NamespaceCreateRequest {
    #[inline]
    fn take_from(from: &WireNamespaceCreateRequest) -> Self {
        Self { entries: ::fidl_next::TakeFrom::take_from(&from.entries) }
    }
}

/// The wire type corresponding to [`NamespaceCreateRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireNamespaceCreateRequest {
    pub entries: ::fidl_next::WireVector<crate::WireNamespaceInputEntry>,
}

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

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

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

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<NamespaceCreateResponse> {
    type EncodedOption = ::fidl_next::WireBox<WireNamespaceCreateResponse>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireNamespaceCreateResponse> for NamespaceCreateResponse {
    #[inline]
    fn take_from(from: &WireNamespaceCreateResponse) -> Self {
        Self { entries: ::fidl_next::TakeFrom::take_from(&from.entries) }
    }
}

/// The wire type corresponding to [`NamespaceCreateResponse`].
#[derive(Debug)]
#[repr(C)]
pub struct WireNamespaceCreateResponse {
    pub entries: ::fidl_next::WireVector<crate::WireNamespaceEntry>,
}

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

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

        type Response = ::fidl_next::WireFlexibleResult<
            crate::WireNamespaceCreateResponse,
            crate::WireNamespaceError,
        >;
    }
}

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

    fn create<___R>(
        &self,
        request: &mut ___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,
        >;
}

impl<___T> NamespaceClientSender for ::fidl_next::ClientSender<___T, Namespace>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;

    fn create<___R>(
        &self,
        request: &mut ___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,
        >,
    {
        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::RequestBuffer<___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>,

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

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

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

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

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

            } = out;
        }

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<RealmDestroyChildRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireRealmDestroyChildRequest>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireRealmDestroyChildRequest> for RealmDestroyChildRequest {
    #[inline]
    fn take_from(from: &WireRealmDestroyChildRequest) -> Self {
        Self { child: ::fidl_next::TakeFrom::take_from(&from.child) }
    }
}

/// The wire type corresponding to [`RealmDestroyChildRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireRealmDestroyChildRequest {
    pub child: ::fidl_next_fuchsia_component_decl::WireChildRef,
}

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

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

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<RealmListChildrenRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireRealmListChildrenRequest>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireRealmListChildrenRequest> for RealmListChildrenRequest {
    #[inline]
    fn take_from(from: &WireRealmListChildrenRequest) -> Self {
        Self {
            collection: ::fidl_next::TakeFrom::take_from(&from.collection),

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

/// The wire type corresponding to [`RealmListChildrenRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireRealmListChildrenRequest {
    pub collection: ::fidl_next_fuchsia_component_decl::WireCollectionRef,

    pub iter: ::fidl_next::ServerEnd<::fidl_next::fuchsia::WireChannel, crate::ChildIterator>,
}

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

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<RealmOpenControllerRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireRealmOpenControllerRequest>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireRealmOpenControllerRequest> for RealmOpenControllerRequest {
    #[inline]
    fn take_from(from: &WireRealmOpenControllerRequest) -> Self {
        Self {
            child: ::fidl_next::TakeFrom::take_from(&from.child),

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

/// The wire type corresponding to [`RealmOpenControllerRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireRealmOpenControllerRequest {
    pub child: ::fidl_next_fuchsia_component_decl::WireChildRef,

    pub controller: ::fidl_next::ServerEnd<::fidl_next::fuchsia::WireChannel, crate::Controller>,
}

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

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<RealmOpenExposedDirRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireRealmOpenExposedDirRequest>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireRealmOpenExposedDirRequest> for RealmOpenExposedDirRequest {
    #[inline]
    fn take_from(from: &WireRealmOpenExposedDirRequest) -> Self {
        Self {
            child: ::fidl_next::TakeFrom::take_from(&from.child),

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

/// The wire type corresponding to [`RealmOpenExposedDirRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireRealmOpenExposedDirRequest {
    pub child: ::fidl_next_fuchsia_component_decl::WireChildRef,

    pub exposed_dir: ::fidl_next::ServerEnd<
        ::fidl_next::fuchsia::WireChannel,
        ::fidl_next_fuchsia_io::Directory,
    >,
}

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

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

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<RealmCreateChildRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireRealmCreateChildRequest>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireRealmCreateChildRequest> for RealmCreateChildRequest {
    #[inline]
    fn take_from(from: &WireRealmCreateChildRequest) -> Self {
        Self {
            collection: ::fidl_next::TakeFrom::take_from(&from.collection),

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

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

/// The wire type corresponding to [`RealmCreateChildRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireRealmCreateChildRequest {
    pub collection: ::fidl_next_fuchsia_component_decl::WireCollectionRef,

    pub decl: ::fidl_next_fuchsia_component_decl::WireChild,

    pub args: crate::WireCreateChildArgs,
}

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

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

/// 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 = "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::RealmListChildrenRequest;

        pub use crate::RealmOpenControllerRequest;

        pub use crate::RealmOpenExposedDirRequest;

        pub use crate::RealmCreateChildResponse;

        pub use crate::RealmDestroyChildResponse;

        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;

        type Response =
            ::fidl_next::WireResult<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;

        type Response =
            ::fidl_next::WireResult<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;

        type Response =
            ::fidl_next::WireResult<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;

        type Response =
            ::fidl_next::WireResult<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;

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

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

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

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

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

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: &mut ___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,
        >,
    {
        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: &mut ___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,
        >,
    {
        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: &mut ___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,
        >,
    {
        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: &mut ___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,
        >,
    {
        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: &mut ___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,
        >,
    {
        self.as_untyped()
            .send_two_way(7532454435519185057, 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>,
{
    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::RequestBuffer<___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::RequestBuffer<___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::RequestBuffer<___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::RequestBuffer<___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::RequestBuffer<___T, realm::ListChildren>,

        responder: ::fidl_next::Responder<realm::ListChildren>,
    );
}

impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for Realm
where
    ___T: ::fidl_next::Transport,
    ___H: RealmServerHandler<___T>,

    crate::WireRealmOpenControllerRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireRealmOpenExposedDirRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireRealmCreateChildRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    crate::WireRealmDestroyChildRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

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

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

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

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

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

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

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

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

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

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

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

pub type ChildName = String;

/// The wire type corresponding to [`ChildName`].
pub type WireChildName = ::fidl_next::WireString;

pub type UrlScheme = String;

/// The wire type corresponding to [`UrlScheme`].
pub type WireUrlScheme = ::fidl_next::WireString;

/// 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 ::fidl_next::TakeFrom<crate::Binder> for ::fidl_fuchsia_component::BinderMarker {
        #[inline]
        fn take_from(from: &crate::Binder) -> Self {
            Self
        }
    }

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

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

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

    impl ::fidl_next::TakeFrom<crate::WireChildIteratorNextResponse>
        for ::fidl_fuchsia_component::ChildIteratorNextResponse
    {
        #[inline]
        fn take_from(from: &crate::WireChildIteratorNextResponse) -> Self {
            Self { children: ::fidl_next::TakeFrom::take_from(&from.children) }
        }
    }

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

    impl ::fidl_next::TakeFrom<crate::WireControllerIsStartedResponse>
        for ::fidl_fuchsia_component::ControllerIsStartedResponse
    {
        #[inline]
        fn take_from(from: &crate::WireControllerIsStartedResponse) -> Self {
            Self { is_started: ::fidl_next::TakeFrom::take_from(&from.is_started) }
        }
    }

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

    impl ::fidl_next::TakeFrom<crate::WireNamespaceEntry> for ::fidl_fuchsia_component::NamespaceEntry {
        #[inline]
        fn take_from(from: &crate::WireNamespaceEntry) -> Self {
            Self {
                path: from.path().map(::fidl_next::TakeFrom::take_from),

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

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

    impl ::fidl_next::TakeFrom<crate::WireStartChildArgs> for ::fidl_fuchsia_component::StartChildArgs {
        #[inline]
        fn take_from(from: &crate::WireStartChildArgs) -> Self {
            Self {
                numbered_handles: from.numbered_handles().map(::fidl_next::TakeFrom::take_from),

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

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

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

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

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

    impl ::fidl_next::TakeFrom<crate::WireControllerGetExposedDictionaryResponse>
        for ::fidl_fuchsia_component::ControllerGetExposedDictionaryResponse
    {
        #[inline]
        fn take_from(from: &crate::WireControllerGetExposedDictionaryResponse) -> Self {
            Self { dictionary: ::fidl_next::TakeFrom::take_from(&from.dictionary) }
        }
    }

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

    impl ::fidl_next::TakeFrom<crate::WireCreateChildArgs>
        for ::fidl_fuchsia_component::CreateChildArgs
    {
        #[inline]
        fn take_from(from: &crate::WireCreateChildArgs) -> Self {
            Self {
                numbered_handles: from.numbered_handles().map(::fidl_next::TakeFrom::take_from),

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

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

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

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

    impl ::fidl_next::TakeFrom<crate::WireDebugStartedPayload>
        for ::fidl_fuchsia_component::DebugStartedPayload
    {
        #[inline]
        fn take_from(from: &crate::WireDebugStartedPayload) -> Self {
            Self {
                runtime_dir: from.runtime_dir().map(::fidl_next::TakeFrom::take_from),

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

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

    impl ::fidl_next::TakeFrom<crate::WireDestroyedPayload>
        for ::fidl_fuchsia_component::DestroyedPayload
    {
        #[inline]
        fn take_from(from: &crate::WireDestroyedPayload) -> Self {
            Self { __source_breaking: ::fidl::marker::SourceBreaking }
        }
    }

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

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

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

    impl ::fidl_next::TakeFrom<crate::WireDiscoveredPayload>
        for ::fidl_fuchsia_component::DiscoveredPayload
    {
        #[inline]
        fn take_from(from: &crate::WireDiscoveredPayload) -> Self {
            Self { __source_breaking: ::fidl::marker::SourceBreaking }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WirePurgedPayload> for ::fidl_fuchsia_component::PurgedPayload {
        #[inline]
        fn take_from(from: &crate::WirePurgedPayload) -> Self {
            Self { __source_breaking: ::fidl::marker::SourceBreaking }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireResolvedPayload>
        for ::fidl_fuchsia_component::ResolvedPayload
    {
        #[inline]
        fn take_from(from: &crate::WireResolvedPayload) -> Self {
            Self { __source_breaking: ::fidl::marker::SourceBreaking }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireStartedPayload> for ::fidl_fuchsia_component::StartedPayload {
        #[inline]
        fn take_from(from: &crate::WireStartedPayload) -> Self {
            Self { __source_breaking: ::fidl::marker::SourceBreaking }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireUnresolvedPayload>
        for ::fidl_fuchsia_component::UnresolvedPayload
    {
        #[inline]
        fn take_from(from: &crate::WireUnresolvedPayload) -> Self {
            Self { __source_breaking: ::fidl::marker::SourceBreaking }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireStoppedPayload> for ::fidl_fuchsia_component::StoppedPayload {
        #[inline]
        fn take_from(from: &crate::WireStoppedPayload) -> Self {
            Self {
                status: from.status().map(::fidl_next::TakeFrom::take_from),

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

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

    impl ::fidl_next::TakeFrom<crate::WireEventType> for ::fidl_fuchsia_component::EventType {
        #[inline]
        fn take_from(from: &crate::WireEventType) -> 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,
            }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireEventHeader> for ::fidl_fuchsia_component::EventHeader {
        #[inline]
        fn take_from(from: &crate::WireEventHeader) -> Self {
            Self {
                event_type: from.event_type().map(::fidl_next::TakeFrom::take_from),

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

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

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

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

    impl ::fidl_next::TakeFrom<crate::WireEventPayload> for ::fidl_fuchsia_component::EventPayload {
        #[inline]
        fn take_from(from: &crate::WireEventPayload) -> Self {
            match from.as_ref() {
                crate::event_payload::Ref::CapabilityRequested(value) => {
                    Self::CapabilityRequested(::fidl_next::TakeFrom::take_from(value))
                }

                crate::event_payload::Ref::Purged(value) => {
                    Self::Purged(::fidl_next::TakeFrom::take_from(value))
                }

                crate::event_payload::Ref::DirectoryReady(value) => {
                    Self::DirectoryReady(::fidl_next::TakeFrom::take_from(value))
                }

                crate::event_payload::Ref::Discovered(value) => {
                    Self::Discovered(::fidl_next::TakeFrom::take_from(value))
                }

                crate::event_payload::Ref::Destroyed(value) => {
                    Self::Destroyed(::fidl_next::TakeFrom::take_from(value))
                }

                crate::event_payload::Ref::Resolved(value) => {
                    Self::Resolved(::fidl_next::TakeFrom::take_from(value))
                }

                crate::event_payload::Ref::Started(value) => {
                    Self::Started(::fidl_next::TakeFrom::take_from(value))
                }

                crate::event_payload::Ref::Stopped(value) => {
                    Self::Stopped(::fidl_next::TakeFrom::take_from(value))
                }

                crate::event_payload::Ref::DebugStarted(value) => {
                    Self::DebugStarted(::fidl_next::TakeFrom::take_from(value))
                }

                crate::event_payload::Ref::Unresolved(value) => {
                    Self::Unresolved(::fidl_next::TakeFrom::take_from(value))
                }

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

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

    impl ::fidl_next::TakeFrom<crate::WireEvent> for ::fidl_fuchsia_component::Event {
        #[inline]
        fn take_from(from: &crate::WireEvent) -> Self {
            Self {
                header: from.header().map(::fidl_next::TakeFrom::take_from),

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

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

    impl ::fidl_next::TakeFrom<crate::WireEventStreamGetNextResponse>
        for ::fidl_fuchsia_component::EventStreamGetNextResponse
    {
        #[inline]
        fn take_from(from: &crate::WireEventStreamGetNextResponse) -> Self {
            Self { events: ::fidl_next::TakeFrom::take_from(&from.events) }
        }
    }

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

    impl ::fidl_next::TakeFrom<crate::WireExecutionControllerOnStopRequest>
        for ::fidl_fuchsia_component::ExecutionControllerOnStopRequest
    {
        #[inline]
        fn take_from(from: &crate::WireExecutionControllerOnStopRequest) -> Self {
            Self { stopped_payload: ::fidl_next::TakeFrom::take_from(&from.stopped_payload) }
        }
    }

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

    impl ::fidl_next::TakeFrom<crate::WireIntrospectorGetMonikerRequest>
        for ::fidl_fuchsia_component::IntrospectorGetMonikerRequest
    {
        #[inline]
        fn take_from(from: &crate::WireIntrospectorGetMonikerRequest) -> Self {
            Self { component_instance: ::fidl_next::TakeFrom::take_from(&from.component_instance) }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireIntrospectorGetMonikerResponse>
        for ::fidl_fuchsia_component::IntrospectorGetMonikerResponse
    {
        #[inline]
        fn take_from(from: &crate::WireIntrospectorGetMonikerResponse) -> Self {
            Self { moniker: ::fidl_next::TakeFrom::take_from(&from.moniker) }
        }
    }

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

    impl ::fidl_next::TakeFrom<crate::WireNamespaceInputEntry>
        for ::fidl_fuchsia_component::NamespaceInputEntry
    {
        #[inline]
        fn take_from(from: &crate::WireNamespaceInputEntry) -> Self {
            Self {
                path: ::fidl_next::TakeFrom::take_from(&from.path),

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

    impl ::fidl_next::TakeFrom<crate::WireNamespaceCreateRequest>
        for ::fidl_fuchsia_component::NamespaceCreateRequest
    {
        #[inline]
        fn take_from(from: &crate::WireNamespaceCreateRequest) -> Self {
            Self { entries: ::fidl_next::TakeFrom::take_from(&from.entries) }
        }
    }

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

    impl ::fidl_next::TakeFrom<crate::WireNamespaceCreateResponse>
        for ::fidl_fuchsia_component::NamespaceCreateResponse
    {
        #[inline]
        fn take_from(from: &crate::WireNamespaceCreateResponse) -> Self {
            Self { entries: ::fidl_next::TakeFrom::take_from(&from.entries) }
        }
    }

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

    impl ::fidl_next::TakeFrom<crate::WireRealmDestroyChildRequest>
        for ::fidl_fuchsia_component::RealmDestroyChildRequest
    {
        #[inline]
        fn take_from(from: &crate::WireRealmDestroyChildRequest) -> Self {
            Self { child: ::fidl_next::TakeFrom::take_from(&from.child) }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireRealmListChildrenRequest>
        for ::fidl_fuchsia_component::RealmListChildrenRequest
    {
        #[inline]
        fn take_from(from: &crate::WireRealmListChildrenRequest) -> Self {
            Self {
                collection: ::fidl_next::TakeFrom::take_from(&from.collection),

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

    impl ::fidl_next::TakeFrom<crate::WireRealmOpenControllerRequest>
        for ::fidl_fuchsia_component::RealmOpenControllerRequest
    {
        #[inline]
        fn take_from(from: &crate::WireRealmOpenControllerRequest) -> Self {
            Self {
                child: ::fidl_next::TakeFrom::take_from(&from.child),

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

    impl ::fidl_next::TakeFrom<crate::WireRealmOpenExposedDirRequest>
        for ::fidl_fuchsia_component::RealmOpenExposedDirRequest
    {
        #[inline]
        fn take_from(from: &crate::WireRealmOpenExposedDirRequest) -> Self {
            Self {
                child: ::fidl_next::TakeFrom::take_from(&from.child),

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

    impl ::fidl_next::TakeFrom<crate::WireRealmCreateChildRequest>
        for ::fidl_fuchsia_component::RealmCreateChildRequest
    {
        #[inline]
        fn take_from(from: &crate::WireRealmCreateChildRequest) -> Self {
            Self {
                collection: ::fidl_next::TakeFrom::take_from(&from.collection),

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

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

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