fidl_next_fuchsia_component_runner/

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

#[derive(Debug)]
pub enum Task {
    Job(::fidl_next::fuchsia::zx::Handle),

    Process(::fidl_next::fuchsia::zx::Handle),

    Thread(::fidl_next::fuchsia::zx::Handle),

    UnknownOrdinal_(u64),
}

impl ::fidl_next::Encodable for Task {
    type Encoded = WireTask;
}

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

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

        match self {
            Self::Job(value) => ::fidl_next::RawWireUnion::encode_as_static::<
                ___E,
                ::fidl_next::fuchsia::zx::Handle,
            >(value, 1, encoder, raw)?,

            Self::Process(value) => ::fidl_next::RawWireUnion::encode_as_static::<
                ___E,
                ::fidl_next::fuchsia::zx::Handle,
            >(value, 2, encoder, raw)?,

            Self::Thread(value) => ::fidl_next::RawWireUnion::encode_as_static::<
                ___E,
                ::fidl_next::fuchsia::zx::Handle,
            >(value, 3, encoder, raw)?,

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Task {
    type EncodedOption = WireOptionalTask;
}

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

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

        Ok(())
    }
}

impl ::fidl_next::FromWire<WireTask> for Task {
    #[inline]
    fn from_wire(wire: WireTask) -> Self {
        let wire = ::core::mem::ManuallyDrop::new(wire);
        match wire.raw.ordinal() {
            1 => Self::Job(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<::fidl_next::fuchsia::WireHandle>()
            })),

            2 => Self::Process(::fidl_next::FromWire::from_wire(unsafe {
                wire.raw.get().read_unchecked::<::fidl_next::fuchsia::WireHandle>()
            })),

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

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

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

/// The wire type corresponding to [`Task`].
#[repr(transparent)]
pub struct WireTask {
    raw: ::fidl_next::RawWireUnion,
    _phantom: ::core::marker::PhantomData<()>,
}

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

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

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

            _ => (),
        }
    }
}

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

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

pub mod task {
    pub enum Ref<'de> {
        Job(&'de ::fidl_next::fuchsia::WireHandle),

        Process(&'de ::fidl_next::fuchsia::WireHandle),

        Thread(&'de ::fidl_next::fuchsia::WireHandle),

        UnknownOrdinal_(u64),
    }
}

impl WireTask {
    pub fn as_ref(&self) -> crate::task::Ref<'_> {
        match self.raw.ordinal() {
            1 => crate::task::Ref::Job(unsafe {
                self.raw.get().deref_unchecked::<::fidl_next::fuchsia::WireHandle>()
            }),

            2 => crate::task::Ref::Process(unsafe {
                self.raw.get().deref_unchecked::<::fidl_next::fuchsia::WireHandle>()
            }),

            3 => crate::task::Ref::Thread(unsafe {
                self.raw.get().deref_unchecked::<::fidl_next::fuchsia::WireHandle>()
            }),

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

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

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

            2 => ::fidl_next::RawWireUnion::decode_as_static::<
                ___D,
                ::fidl_next::fuchsia::WireHandle,
            >(raw, decoder)?,

            3 => ::fidl_next::RawWireUnion::decode_as_static::<
                ___D,
                ::fidl_next::fuchsia::WireHandle,
            >(raw, decoder)?,

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

        Ok(())
    }
}

impl ::core::fmt::Debug for WireTask {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        match self.raw.ordinal() {
            1 => unsafe {
                self.raw.get().deref_unchecked::<::fidl_next::fuchsia::WireHandle>().fmt(f)
            },
            2 => unsafe {
                self.raw.get().deref_unchecked::<::fidl_next::fuchsia::WireHandle>().fmt(f)
            },
            3 => unsafe {
                self.raw.get().deref_unchecked::<::fidl_next::fuchsia::WireHandle>().fmt(f)
            },
            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

#[repr(transparent)]
pub struct WireOptionalTask {
    raw: ::fidl_next::RawWireUnion,
    _phantom: ::core::marker::PhantomData<()>,
}

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

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

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

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

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

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

            2 => ::fidl_next::RawWireUnion::decode_as_static::<
                ___D,
                ::fidl_next::fuchsia::WireHandle,
            >(raw, decoder)?,

            3 => ::fidl_next::RawWireUnion::decode_as_static::<
                ___D,
                ::fidl_next::fuchsia::WireHandle,
            >(raw, decoder)?,

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

        Ok(())
    }
}

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

#[derive(Debug, Default)]
pub struct ComponentTasks {
    pub component_task: Option<crate::Task>,

    pub parent_task: Option<crate::Task>,
}

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

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

        0
    }
}

impl ::fidl_next::Encodable for ComponentTasks {
    type Encoded = WireComponentTasks<'static>;
}

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

        let max_ord = self.__max_ordinal();

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

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

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

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

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

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

        Ok(())
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

                    Ok(())
                }

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

                    Ok(())
                }

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

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

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

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

#[derive(Debug, Default)]
pub struct ComponentDiagnostics {
    pub tasks: Option<crate::ComponentTasks>,
}

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

        0
    }
}

impl ::fidl_next::Encodable for ComponentDiagnostics {
    type Encoded = WireComponentDiagnostics<'static>;
}

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

        let max_ord = self.__max_ordinal();

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

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

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

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

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

        Ok(())
    }
}

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

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

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

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

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

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

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

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

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

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

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

                    Ok(())
                }

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

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

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

#[derive(Debug)]
pub struct ComponentControllerOnPublishDiagnosticsRequest {
    pub payload: crate::ComponentDiagnostics,
}

impl ::fidl_next::Encodable for ComponentControllerOnPublishDiagnosticsRequest {
    type Encoded = WireComponentControllerOnPublishDiagnosticsRequest<'static>;
}

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

    ___E: ::fidl_next::Encoder,

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

            } = out;
        }

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

impl<'de> ::fidl_next::FromWire<WireComponentControllerOnPublishDiagnosticsRequest<'de>>
    for ComponentControllerOnPublishDiagnosticsRequest
{
    #[inline]
    fn from_wire(wire: WireComponentControllerOnPublishDiagnosticsRequest<'de>) -> Self {
        Self { payload: ::fidl_next::FromWire::from_wire(wire.payload) }
    }
}

/// The wire type corresponding to [`ComponentControllerOnPublishDiagnosticsRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireComponentControllerOnPublishDiagnosticsRequest<'de> {
    pub payload: crate::WireComponentDiagnostics<'de>,
}

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

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

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

    ___D: ::fidl_next::Decoder,

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

            } = slot;
        }

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

        Ok(())
    }
}

#[derive(Debug, Default)]
pub struct ComponentControllerOnEscrowRequest {
    pub outgoing_dir: Option<
        ::fidl_next::ServerEnd<
            ::fidl_next_fuchsia_io::Directory,
            ::fidl_next::fuchsia::zx::Channel,
        >,
    >,

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for ComponentControllerOnEscrowRequest {
    type Encoded = WireComponentControllerOnEscrowRequest<'static>;
}

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

        let max_ord = self.__max_ordinal();

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

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

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

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

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

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

        Ok(())
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

                    Ok(())
                }

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

                    Ok(())
                }

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

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

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

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

#[derive(Debug, Default)]
pub struct ComponentStopInfo {
    pub termination_status: Option<i32>,

    pub exit_code: Option<i64>,
}

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

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

        0
    }
}

impl ::fidl_next::Encodable for ComponentStopInfo {
    type Encoded = WireComponentStopInfo<'static>;
}

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

        let max_ord = self.__max_ordinal();

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

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

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

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

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

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

        Ok(())
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

                    Ok(())
                }

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

                    Ok(())
                }

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

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

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

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

/// The type corresponding to the ComponentController protocol.
#[doc = " A protocol for binding and controlling the lifetime of a component instance\n started using `ComponentRunner.Start()`. The component manager is the\n intended direct client of this protocol.\n\n When the controlled component instance terminates or becomes inaccessible\n for any reason, the server closes the connection with an epitaph.\n\n # Lifecycle\n\n A component may exist in one of two states: `Started`, or `Stopped`. The\n component is `Started` from the time `ComponentRunner.Start()` is called\n until the ComponentRunner closes the ComponentController handle. The\n component then transitions to `Stopped`.\n\n Component manager uses ComponentController to terminate a component in two\n steps:\n\n 1.  Component manager calls `Stop()` to indicate that the ComponentRunner\n     should stop a component\'s execution and send the `OnStop` event.\n 2.  If after some time the ComponentController is not closed, component\n     manager calls `Kill()` to indicate that the ComponentRunner must halt a\n     component\'s execution immediately, and then send the `OnStop` event.\n     The component manager may wait some period of time after calling `Kill()`\n     before sending `OnStop`, but makes no guarantees it will wait or for how long.\n\n Component manager first waits for the ComponentController to close, and\n then tears down the namespace it hosts for the stopped component. Component\n manager may call `Kill()` without first having called `Stop()`.\n\n Before stopping, a component can optionally use `OnEscrow` to store some\n state in the framework, to receive those state again the next time it is\n started.\n\n When the component stops, the runner should send an `OnStop` event\n instead of just closing the channel, to report the component\'s termination status\n (see below) and (optionally) an exit code. Once the runner has sent `OnStop`\n it is free to close [ComponentRunner]; the component framework will close\n its end of the channel when it receives this event.\n\n ## Legacy\n\n Instead of sending `OnStop`, it is also legal for a runner to close the channel\n with with an epitaph equal to the termination status, but this is a legacy method\n for backward compatibility that\'s no longer recommended.\n\n # Termination status\n\n The termination status indicates the component\'s final disposition in the eyes of\n the runner.\n\n Note that termination status is _not_ synonymous with a component\'s exit code.\n A component\'s exit code, which is optional for a runner to report, is an\n integer that represents the program\'s own return code. For example, for ELF\n components, it is the value returned by main(). The termination status is\n the _runner_\'s status code for the component\'s termination, which may capture\n failure modes that occur in the context of the runner itself rather than the\n program.\n\n The following termination statuses may be sent by the server on error:\n\n - `ZX_OK`: The component exited successfully, typically because the\n   component was asked to stop or it decided independently to exit.\n - `INVALID_ARGUMENTS`:\n     * `start_info.resolved_url` is not supported by this\n       runner;\n     * `start_info` contains missing or invalid arguments.\n - `INSTANCE_CANNOT_START`: The runner could not start the component.\n   For example, a critical part of the program could not be found or\n   loaded, or the referenced binary was invalid for this runner.\n - `RESOURCE_UNAVAILABLE`: The component could not be launched due to\n   lack of resources.\n - `INTERNAL`: An unexpected internal runner error was encountered.\n - `INSTANCE_DIED`: The component instance was started but\n   subsequently terminated with an error.\n - Other status codes (e.g. `ZX_ERR_PEER_CLOSED`) may indicate a failure\n   of the component runner itself. The component manager may respond to such\n   failures by terminating the component runner\'s job to ensure system\n   stability.\n"]
#[derive(Debug)]
pub struct ComponentController;

pub mod component_controller {
    pub mod prelude {
        pub use crate::{
            component_controller, ComponentController, ComponentControllerClientHandler,
            ComponentControllerServerHandler,
        };

        pub use crate::ComponentControllerOnEscrowRequest;

        pub use crate::ComponentControllerOnPublishDiagnosticsRequest;

        pub use crate::ComponentStopInfo;
    }

    pub struct Stop;

    impl ::fidl_next::Method for Stop {
        const ORDINAL: u64 = 4804506821232171874;

        type Protocol = crate::ComponentController;

        type Request = ();

        type Response = ::fidl_next::Never;
    }

    pub struct Kill;

    impl ::fidl_next::Method for Kill {
        const ORDINAL: u64 = 4514346391631670964;

        type Protocol = crate::ComponentController;

        type Request = ();

        type Response = ::fidl_next::Never;
    }

    pub struct OnPublishDiagnostics;

    impl ::fidl_next::Method for OnPublishDiagnostics {
        const ORDINAL: u64 = 2240216199992207687;

        type Protocol = crate::ComponentController;

        type Request = ::fidl_next::Never;

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

    pub struct OnEscrow;

    impl ::fidl_next::Method for OnEscrow {
        const ORDINAL: u64 = 730448769712342012;

        type Protocol = crate::ComponentController;

        type Request = ::fidl_next::Never;

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

    pub struct OnStop;

    impl ::fidl_next::Method for OnStop {
        const ORDINAL: u64 = 4322651556509354674;

        type Protocol = crate::ComponentController;

        type Request = ::fidl_next::Never;

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

    mod ___detail {

        pub struct OnPublishDiagnostics<T0> {
            payload: T0,
        }

        impl<T0> ::fidl_next::Encodable for OnPublishDiagnostics<T0>
        where
            T0: ::fidl_next::Encodable<Encoded = crate::WireComponentDiagnostics<'static>>,
        {
            type Encoded = crate::WireComponentControllerOnPublishDiagnosticsRequest<'static>;
        }

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

            ___E: ::fidl_next::Encoder,

            ___E: ::fidl_next::fuchsia::HandleEncoder,

            T0: ::fidl_next::Encode<___E, Encoded = crate::WireComponentDiagnostics<'static>>,
        {
            #[inline]
            fn encode(
                self,
                encoder: &mut ___E,
                out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
            ) -> Result<(), ::fidl_next::EncodeError> {
                ::fidl_next::munge! {
                    let Self::Encoded {
                        payload,

                    } = out;
                }

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

                Ok(())
            }
        }

        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::ComponentController
        where
            ___T: ::fidl_next::Transport,
        {
            type ClientSender = ComponentControllerClientSender<___T>;
            type ServerSender = ComponentControllerServerSender<___T>;
        }

        /// The client sender for the `ComponentController` protocol.
        pub struct ComponentControllerClientSender<___T: ::fidl_next::Transport> {
            #[allow(dead_code)]
            sender: ::fidl_next::protocol::ClientSender<___T>,
        }

        impl<___T> ComponentControllerClientSender<___T>
        where
            ___T: ::fidl_next::Transport,
        {
            #[doc = " Request to stop the component instance.\n\n After stopping the component instance, the server should close this\n connection with an epitaph. After the connection\n closes, component manager considers this component instance to be\n Stopped and the component\'s namespace will be torn down.\n"]
            pub fn stop(
                &self,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError> {
                self.sender.send_one_way(4804506821232171874, ())
            }

            #[doc = " Stop this component instance immediately.\n\n The ComponentRunner must immediately kill the component instance, and\n then close this connection with an epitaph. After the connection\n closes, component manager considers this component instance to be\n Stopped and the component\'s namespace will be torn down.\n\n In some cases Kill() may be issued before Stop(), but that is not\n guaranteed.\n"]
            pub fn kill(
                &self,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError> {
                self.sender.send_one_way(4514346391631670964, ())
            }
        }

        /// The server sender for the `ComponentController` protocol.
        #[repr(transparent)]
        pub struct ComponentControllerServerSender<___T: ::fidl_next::Transport> {
            sender: ::fidl_next::protocol::ServerSender<___T>,
        }

        impl<___T> ComponentControllerServerSender<___T>
        where
            ___T: ::fidl_next::Transport,
        {
            #[doc = " Event for runners to publish diagnostics to the platform.\n\n This event signals to the platform that the runner for this\n component is publishing diagnostics about the runtime of the\n component. The component manager may optionally expose this data\n to clients.\n"]
            pub fn on_publish_diagnostics(
                &self,

                payload: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireComponentDiagnostics<'static>,
                >,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.on_publish_diagnostics_with(OnPublishDiagnostics { payload })
            }

            #[doc = " Event for runners to publish diagnostics to the platform.\n\n This event signals to the platform that the runner for this\n component is publishing diagnostics about the runtime of the\n component. The component manager may optionally expose this data\n to clients.\n"]

            pub fn on_publish_diagnostics_with<___R>(
                &self,
                request: ___R,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = <super::OnPublishDiagnostics as ::fidl_next::Method>::Response,
                >,
            {
                self.sender.send_event(2240216199992207687, request)
            }

            #[doc = " Store some of the component\'s state in the framework, to be redelivered\n to the component the next time it\'s started (a practice called\n \"escrowing\").\n\n When the framework receives this event, it will wait until the current\n execution of the component has finished, then start the component again\n when the `ZX_CHANNEL_READABLE` signal is observed on `outgoing_dir`.\n\n Repeated calls will replace the old escrowed value. This is discouraged.\n\n Handles escrowed via `OnEscrow` are always delivered to the next\n execution of the component.\n"]

            pub fn on_escrow_with<___R>(
                &self,
                request: ___R,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = <super::OnEscrow as ::fidl_next::Method>::Response,
                >,
            {
                self.sender.send_event(730448769712342012, request)
            }

            #[doc = " Report that the component has stopped, with data about its termination. This will\n cause the component to make a lifecycle transition to `Stopped`.\n\n Once the runner has sent `OnStop` it is free to close this [ComponentRunner]; the\n component framework will close its end of the channel when it receives this event.\n\n Alternatively, a runner may close the controller channel without this event to signal\n component stop, but this method is legacy and no longer recommended.\n"]

            pub fn on_stop_with<___R>(
                &self,
                request: ___R,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = <super::OnStop as ::fidl_next::Method>::Response,
                >,
            {
                self.sender.send_event(4322651556509354674, request)
            }
        }
    }
}

/// A client handler for the ComponentController protocol.
///
/// See [`ComponentController`] for more details.
pub trait ComponentControllerClientHandler<___T: ::fidl_next::Transport> {
    #[doc = " Event for runners to publish diagnostics to the platform.\n\n This event signals to the platform that the runner for this\n component is publishing diagnostics about the runtime of the\n component. The component manager may optionally expose this data\n to clients.\n"]
    fn on_publish_diagnostics(
        &mut self,
        sender: &::fidl_next::ClientSender<ComponentController, ___T>,

        event: ::fidl_next::Response<component_controller::OnPublishDiagnostics, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[doc = " Store some of the component\'s state in the framework, to be redelivered\n to the component the next time it\'s started (a practice called\n \"escrowing\").\n\n When the framework receives this event, it will wait until the current\n execution of the component has finished, then start the component again\n when the `ZX_CHANNEL_READABLE` signal is observed on `outgoing_dir`.\n\n Repeated calls will replace the old escrowed value. This is discouraged.\n\n Handles escrowed via `OnEscrow` are always delivered to the next\n execution of the component.\n"]
    fn on_escrow(
        &mut self,
        sender: &::fidl_next::ClientSender<ComponentController, ___T>,

        event: ::fidl_next::Response<component_controller::OnEscrow, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[doc = " Report that the component has stopped, with data about its termination. This will\n cause the component to make a lifecycle transition to `Stopped`.\n\n Once the runner has sent `OnStop` it is free to close this [ComponentRunner]; the\n component framework will close its end of the channel when it receives this event.\n\n Alternatively, a runner may close the controller channel without this event to signal\n component stop, but this method is legacy and no longer recommended.\n"]
    fn on_stop(
        &mut self,
        sender: &::fidl_next::ClientSender<ComponentController, ___T>,

        event: ::fidl_next::Response<component_controller::OnStop, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ClientSender<ComponentController, ___T>,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        sender.close();
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::ClientProtocol<___H, ___T> for ComponentController
where
    ___H: ComponentControllerClientHandler<___T> + Send,
    ___T: ::fidl_next::Transport,

    <component_controller::OnPublishDiagnostics as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <component_controller::OnEscrow as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <component_controller::OnStop as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    async fn on_event(
        handler: &mut ___H,
        sender: &::fidl_next::ClientSender<Self, ___T>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            2240216199992207687 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => handler.on_publish_diagnostics(sender, decoded).await,
                Err(e) => {
                    sender.close();
                }
            },

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

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

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

/// A server handler for the ComponentController protocol.
///
/// See [`ComponentController`] for more details.
pub trait ComponentControllerServerHandler<___T: ::fidl_next::Transport> {
    #[doc = " Request to stop the component instance.\n\n After stopping the component instance, the server should close this\n connection with an epitaph. After the connection\n closes, component manager considers this component instance to be\n Stopped and the component\'s namespace will be torn down.\n"]
    fn stop(
        &mut self,
        sender: &::fidl_next::ServerSender<ComponentController, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[doc = " Stop this component instance immediately.\n\n The ComponentRunner must immediately kill the component instance, and\n then close this connection with an epitaph. After the connection\n closes, component manager considers this component instance to be\n Stopped and the component\'s namespace will be torn down.\n\n In some cases Kill() may be issued before Stop(), but that is not\n guaranteed.\n"]
    fn kill(
        &mut self,
        sender: &::fidl_next::ServerSender<ComponentController, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ServerSender<ComponentController, ___T>,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        sender.close();
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::ServerProtocol<___H, ___T> for ComponentController
where
    ___H: ComponentControllerServerHandler<___T> + Send,
    ___T: ::fidl_next::Transport,
{
    async fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<Self, ___T>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            4804506821232171874 => {
                handler.stop(sender).await;
            }

            4514346391631670964 => {
                handler.kill(sender).await;
            }

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

    async fn on_two_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<Self, ___T>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
        responder: ::fidl_next::protocol::Responder,
    ) {
        match ordinal {
            ordinal => handler.on_unknown_interaction(sender, ordinal).await,
        }
    }
}

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

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for ComponentNamespaceEntry {
    type Encoded = WireComponentNamespaceEntry<'static>;
}

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

        let max_ord = self.__max_ordinal();

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

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

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

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

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

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

        Ok(())
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

                    Ok(())
                }

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

                    Ok(())
                }

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

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

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

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

pub const MAX_NAMESPACE_COUNT: u32 = 32;

pub const MAX_HANDLE_COUNT: u32 = 128;

#[doc = " Parameters for starting a new component instance.\n"]
#[derive(Debug, Default)]
pub struct ComponentStartInfo {
    pub resolved_url: Option<String>,

    pub program: Option<::fidl_next_fuchsia_data::Dictionary>,

    pub ns: Option<Vec<crate::ComponentNamespaceEntry>>,

    pub outgoing_dir: Option<
        ::fidl_next::ServerEnd<
            ::fidl_next_fuchsia_io::Directory,
            ::fidl_next::fuchsia::zx::Channel,
        >,
    >,

    pub runtime_dir: Option<
        ::fidl_next::ServerEnd<
            ::fidl_next_fuchsia_io::Directory,
            ::fidl_next::fuchsia::zx::Channel,
        >,
    >,

    pub numbered_handles: Option<Vec<::fidl_next_fuchsia_process::HandleInfo>>,

    pub encoded_config: Option<::fidl_next_fuchsia_mem::Data>,

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

    pub component_instance: Option<::fidl_next::fuchsia::zx::Handle>,

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

impl ComponentStartInfo {
    fn __max_ordinal(&self) -> usize {
        if self.escrowed_dictionary.is_some() {
            return 10;
        }

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

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

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

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

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

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

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

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

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

        0
    }
}

impl ::fidl_next::Encodable for ComponentStartInfo {
    type Encoded = WireComponentStartInfo<'static>;
}

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

        let max_ord = self.__max_ordinal();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        Ok(())
    }
}

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

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

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

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

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

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

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

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

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

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

        let escrowed_dictionary = wire.table.get(10);

        Self {


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


                program: program.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next_fuchsia_data::WireDictionary<'de>>() }
                )),


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


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


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


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


                encoded_config: encoded_config.map(|envelope| ::fidl_next::FromWire::from_wire(
                    unsafe { envelope.read_unchecked::<::fidl_next_fuchsia_mem::WireData<'de>>() }
                )),


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


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


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

        }
    }
}

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

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

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

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

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

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

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

        let _ = self.table.get(7).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next_fuchsia_mem::WireData<'de>>()
        });

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

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

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

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

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

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

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

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

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

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

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

                    Ok(())
                }

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

                    Ok(())
                }

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

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

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

                    Ok(())
                }

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

                    Ok(())
                }

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

                    Ok(())
                }

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

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

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

                    Ok(())
                }

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

                    Ok(())
                }

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

                    Ok(())
                }

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

                    Ok(())
                }

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

                    Ok(())
                }

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

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

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

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

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

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

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

    pub fn encoded_config(&self) -> Option<&::fidl_next_fuchsia_mem::WireData<'de>> {
        unsafe { Some(self.table.get(7)?.deref_unchecked()) }
    }

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

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

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

impl<'de> ::core::fmt::Debug for WireComponentStartInfo<'de> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> Result<(), ::core::fmt::Error> {
        f.debug_struct("ComponentStartInfo")
            .field("resolved_url", &self.resolved_url())
            .field("program", &self.program())
            .field("ns", &self.ns())
            .field("outgoing_dir", &self.outgoing_dir())
            .field("runtime_dir", &self.runtime_dir())
            .field("numbered_handles", &self.numbered_handles())
            .field("encoded_config", &self.encoded_config())
            .field("break_on_start", &self.break_on_start())
            .field("component_instance", &self.component_instance())
            .field("escrowed_dictionary", &self.escrowed_dictionary())
            .finish()
    }
}

#[derive(Debug)]
pub struct ComponentRunnerStartRequest {
    pub start_info: crate::ComponentStartInfo,

    pub controller:
        ::fidl_next::ServerEnd<crate::ComponentController, ::fidl_next::fuchsia::zx::Channel>,
}

impl ::fidl_next::Encodable for ComponentRunnerStartRequest {
    type Encoded = WireComponentRunnerStartRequest<'static>;
}

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

    ___E: ::fidl_next::Encoder,

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

            } = out;
        }

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

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

impl<'de> ::fidl_next::FromWire<WireComponentRunnerStartRequest<'de>>
    for ComponentRunnerStartRequest
{
    #[inline]
    fn from_wire(wire: WireComponentRunnerStartRequest<'de>) -> Self {
        Self {
            start_info: ::fidl_next::FromWire::from_wire(wire.start_info),

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

/// The wire type corresponding to [`ComponentRunnerStartRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireComponentRunnerStartRequest<'de> {
    pub start_info: crate::WireComponentStartInfo<'de>,

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

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

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

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

    ___D: ::fidl_next::Decoder,

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

            } = slot;
        }

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

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

        Ok(())
    }
}

/// The type corresponding to the ComponentRunner protocol.
#[doc = " A protocol used for running components.\n\n This protocol is implemented by components which provide a runtime\n environment for other components.\n\n Note: The component manager is the only intended direct client of this\n interface.\n"]
#[derive(Debug)]
pub struct ComponentRunner;

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

pub mod component_runner {
    pub mod prelude {
        pub use crate::{
            component_runner, ComponentRunner, ComponentRunnerClientHandler,
            ComponentRunnerServerHandler,
        };

        pub use crate::ComponentRunnerStartRequest;
    }

    pub struct Start;

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

        type Protocol = crate::ComponentRunner;

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

        type Response = ::fidl_next::Never;
    }

    mod ___detail {

        pub struct Start<T0, T1> {
            start_info: T0,

            controller: T1,
        }

        impl<T0, T1> ::fidl_next::Encodable for Start<T0, T1>
        where
            T0: ::fidl_next::Encodable<Encoded = crate::WireComponentStartInfo<'static>>,

            T1: ::fidl_next::Encodable<
                Encoded = ::fidl_next::ServerEnd<
                    crate::ComponentController,
                    ::fidl_next::fuchsia::WireChannel,
                >,
            >,
        {
            type Encoded = crate::WireComponentRunnerStartRequest<'static>;
        }

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

            ___E: ::fidl_next::Encoder,

            ___E: ::fidl_next::fuchsia::HandleEncoder,

            T0: ::fidl_next::Encode<___E, Encoded = crate::WireComponentStartInfo<'static>>,

            T1: ::fidl_next::Encode<
                ___E,
                Encoded = ::fidl_next::ServerEnd<
                    crate::ComponentController,
                    ::fidl_next::fuchsia::WireChannel,
                >,
            >,
        {
            #[inline]
            fn encode(
                self,
                encoder: &mut ___E,
                out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
            ) -> Result<(), ::fidl_next::EncodeError> {
                ::fidl_next::munge! {
                    let Self::Encoded {
                        start_info,
                        controller,

                    } = out;
                }

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

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

                Ok(())
            }
        }

        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::ComponentRunner
        where
            ___T: ::fidl_next::Transport,
        {
            type ClientSender = ComponentRunnerClientSender<___T>;
            type ServerSender = ComponentRunnerServerSender<___T>;
        }

        /// The client sender for the `ComponentRunner` protocol.
        pub struct ComponentRunnerClientSender<___T: ::fidl_next::Transport> {
            #[allow(dead_code)]
            sender: ::fidl_next::protocol::ClientSender<___T>,
        }

        impl<___T> ComponentRunnerClientSender<___T>
        where
            ___T: ::fidl_next::Transport,
        {
            #[doc = " Start running a component instance described by `start_info`.\n\n Component manager binds and uses `controller` to control the\n lifetime of the newly started component instance.\n\n Errors are delivered as epitaphs over the `ComponentController`\n protocol. In the event of an error, the runner must ensure that\n resources are cleaned up.\n"]
            pub fn start(
                &self,

                start_info: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireComponentStartInfo<'static>,
                >,

                controller: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::ServerEnd<
                        crate::ComponentController,
                        ::fidl_next::fuchsia::WireChannel,
                    >,
                >,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,

                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.start_with(Start { start_info, controller })
            }

            #[doc = " Start running a component instance described by `start_info`.\n\n Component manager binds and uses `controller` to control the\n lifetime of the newly started component instance.\n\n Errors are delivered as epitaphs over the `ComponentController`\n protocol. In the event of an error, the runner must ensure that\n resources are cleaned up.\n"]
            pub fn start_with<___R>(
                &self,
                request: ___R,
            ) -> Result<::fidl_next::SendFuture<'_, ___T>, ::fidl_next::EncodeError>
            where
                ___R: ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireComponentRunnerStartRequest<'static>,
                >,
            {
                self.sender.send_one_way(780715659970866697, request)
            }
        }

        /// The server sender for the `ComponentRunner` protocol.
        #[repr(transparent)]
        pub struct ComponentRunnerServerSender<___T: ::fidl_next::Transport> {
            sender: ::fidl_next::protocol::ServerSender<___T>,
        }

        impl<___T> ComponentRunnerServerSender<___T> where ___T: ::fidl_next::Transport {}
    }
}

/// A client handler for the ComponentRunner protocol.
///
/// See [`ComponentRunner`] for more details.
pub trait ComponentRunnerClientHandler<___T: ::fidl_next::Transport> {
    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ClientSender<ComponentRunner, ___T>,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        sender.close();
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::ClientProtocol<___H, ___T> for ComponentRunner
where
    ___H: ComponentRunnerClientHandler<___T> + Send,
    ___T: ::fidl_next::Transport,
{
    async fn on_event(
        handler: &mut ___H,
        sender: &::fidl_next::ClientSender<Self, ___T>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => handler.on_unknown_interaction(sender, ordinal).await,
        }
    }
}

/// A server handler for the ComponentRunner protocol.
///
/// See [`ComponentRunner`] for more details.
pub trait ComponentRunnerServerHandler<___T: ::fidl_next::Transport> {
    #[doc = " Start running a component instance described by `start_info`.\n\n Component manager binds and uses `controller` to control the\n lifetime of the newly started component instance.\n\n Errors are delivered as epitaphs over the `ComponentController`\n protocol. In the event of an error, the runner must ensure that\n resources are cleaned up.\n"]
    fn start(
        &mut self,
        sender: &::fidl_next::ServerSender<ComponentRunner, ___T>,

        request: ::fidl_next::Request<component_runner::Start, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ServerSender<ComponentRunner, ___T>,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        sender.close();
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::ServerProtocol<___H, ___T> for ComponentRunner
where
    ___H: ComponentRunnerServerHandler<___T> + Send,
    ___T: ::fidl_next::Transport,

    <component_runner::Start as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    async fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<Self, ___T>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            780715659970866697 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => handler.start(sender, decoded).await,
                Err(e) => {
                    sender.close();
                }
            },

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

    async fn on_two_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<Self, ___T>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
        responder: ::fidl_next::protocol::Responder,
    ) {
        match ordinal {
            ordinal => handler.on_unknown_interaction(sender, ordinal).await,
        }
    }
}

#[derive(Debug)]
#[repr(C)]
pub struct TaskProviderGetJobResponse {
    pub job: ::fidl_next::fuchsia::zx::Handle,
}

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

    type Encoded = WireTaskProviderGetJobResponse;
}

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

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

            } = out;
        }

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

        Ok(())
    }
}

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

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

        Ok(())
    }
}

impl ::fidl_next::FromWire<WireTaskProviderGetJobResponse> for TaskProviderGetJobResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireTaskProviderGetJobResponse, Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <::fidl_next::fuchsia::zx::Handle as ::fidl_next::FromWire<
                ::fidl_next::fuchsia::WireHandle,
            >>::COPY_OPTIMIZATION
                .is_enabled(),
        )
    };

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

/// The wire type corresponding to [`TaskProviderGetJobResponse`].
#[derive(Debug)]
#[repr(C)]
pub struct WireTaskProviderGetJobResponse {
    pub job: ::fidl_next::fuchsia::WireHandle,
}

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

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireTaskProviderGetJobResponse
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 job,

            } = slot;
        }

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

        Ok(())
    }
}

/// The type corresponding to the TaskProvider protocol.
#[doc = " Served by runners that want to make a zircon job available through their runtime directory.\n"]
#[derive(Debug)]
pub struct TaskProvider;

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

pub mod task_provider {
    pub mod prelude {
        pub use crate::{
            task_provider, TaskProvider, TaskProviderClientHandler, TaskProviderServerHandler,
        };

        pub use crate::TaskProviderGetJobResponse;
    }

    pub struct GetJob;

    impl ::fidl_next::Method for GetJob {
        const ORDINAL: u64 = 5520468615388521389;

        type Protocol = crate::TaskProvider;

        type Request = ();

        type Response = ::fidl_next::WireResult<
            'static,
            crate::WireTaskProviderGetJobResponse,
            ::fidl_next::WireI32,
        >;
    }

    mod ___detail {

        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::TaskProvider
        where
            ___T: ::fidl_next::Transport,
        {
            type ClientSender = TaskProviderClientSender<___T>;
            type ServerSender = TaskProviderServerSender<___T>;
        }

        /// The client sender for the `TaskProvider` protocol.
        pub struct TaskProviderClientSender<___T: ::fidl_next::Transport> {
            #[allow(dead_code)]
            sender: ::fidl_next::protocol::ClientSender<___T>,
        }

        impl<___T> TaskProviderClientSender<___T>
        where
            ___T: ::fidl_next::Transport,
        {
            #[doc = " Returns a job handle for the component requested.\n\n On success, returns a handle with the same rights as the runner\'s.\n"]
            pub fn get_job(
                &self,
            ) -> Result<
                ::fidl_next::ResponseFuture<'_, super::GetJob, ___T>,
                ::fidl_next::EncodeError,
            > {
                self.sender
                    .send_two_way(5520468615388521389, ())
                    .map(::fidl_next::ResponseFuture::from_untyped)
            }
        }

        /// The server sender for the `TaskProvider` protocol.
        #[repr(transparent)]
        pub struct TaskProviderServerSender<___T: ::fidl_next::Transport> {
            sender: ::fidl_next::protocol::ServerSender<___T>,
        }

        impl<___T> TaskProviderServerSender<___T> where ___T: ::fidl_next::Transport {}
    }
}

/// A client handler for the TaskProvider protocol.
///
/// See [`TaskProvider`] for more details.
pub trait TaskProviderClientHandler<___T: ::fidl_next::Transport> {
    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ClientSender<TaskProvider, ___T>,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        sender.close();
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::ClientProtocol<___H, ___T> for TaskProvider
where
    ___H: TaskProviderClientHandler<___T> + Send,
    ___T: ::fidl_next::Transport,

    <task_provider::GetJob as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    async fn on_event(
        handler: &mut ___H,
        sender: &::fidl_next::ClientSender<Self, ___T>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => handler.on_unknown_interaction(sender, ordinal).await,
        }
    }
}

/// A server handler for the TaskProvider protocol.
///
/// See [`TaskProvider`] for more details.
pub trait TaskProviderServerHandler<___T: ::fidl_next::Transport> {
    #[doc = " Returns a job handle for the component requested.\n\n On success, returns a handle with the same rights as the runner\'s.\n"]
    fn get_job(
        &mut self,
        sender: &::fidl_next::ServerSender<TaskProvider, ___T>,

        responder: ::fidl_next::Responder<task_provider::GetJob>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn on_unknown_interaction(
        &mut self,
        sender: &::fidl_next::ServerSender<TaskProvider, ___T>,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        sender.close();
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::ServerProtocol<___H, ___T> for TaskProvider
where
    ___H: TaskProviderServerHandler<___T> + Send,
    ___T: ::fidl_next::Transport,
{
    async fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<Self, ___T>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => handler.on_unknown_interaction(sender, ordinal).await,
        }
    }

    async fn on_two_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<Self, ___T>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
        responder: ::fidl_next::protocol::Responder,
    ) {
        match ordinal {
            5520468615388521389 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.get_job(sender, responder).await;
            }

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

/// 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 `ComponentController`
    /// protocol.
    pub type ComponentControllerProxy =
        ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::ComponentController>;

    impl ::core::convert::From<crate::ComponentController>
        for ::fidl_fuchsia_component_runner::ComponentControllerMarker
    {
        #[inline]
        fn from(_: crate::ComponentController) -> Self {
            Self
        }
    }

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client sender over `zx::Channel` for the `ComponentRunner`
    /// protocol.
    pub type ComponentRunnerProxy =
        ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::ComponentRunner>;

    impl ::core::convert::From<crate::ComponentRunner>
        for ::fidl_fuchsia_component_runner::ComponentRunnerMarker
    {
        #[inline]
        fn from(_: crate::ComponentRunner) -> Self {
            Self
        }
    }

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client sender over `zx::Channel` for the `TaskProvider`
    /// protocol.
    pub type TaskProviderProxy =
        ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::TaskProvider>;

    impl ::core::convert::From<crate::TaskProvider>
        for ::fidl_fuchsia_component_runner::TaskProviderMarker
    {
        #[inline]
        fn from(_: crate::TaskProvider) -> Self {
            Self
        }
    }
}