fidl_next_fuchsia_process/

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

#[doc = " Information about a handle provided to a process at startup.\n\n Processes are given a set of initial handles as part of the bootstrapping\n sequence. Some of these handles are associated with process argument\n identifiers that designate their intended use by the new process.\n\n This structure represents one such handle and its associated identifier.\n"]
#[derive(Debug)]
#[repr(C)]
pub struct HandleInfo {
    pub handle: ::fidl_next::fuchsia::zx::Handle,

    pub id: u32,
}

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

    type Encoded = WireHandleInfo;
}

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

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

            } = out;
        }

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<HandleInfo> {
    type EncodedOption = ::fidl_next::WireBox<WireHandleInfo>;
}

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

        Ok(())
    }
}

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

    #[inline]
    fn take_from(from: &WireHandleInfo) -> Self {
        Self {
            handle: ::fidl_next::TakeFrom::take_from(&from.handle),

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

/// The wire type corresponding to [`HandleInfo`].
#[derive(Debug)]
#[repr(C)]
pub struct WireHandleInfo {
    pub handle: ::fidl_next::fuchsia::WireHandle,

    pub id: ::fidl_next::WireU32,
}

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireHandleInfo
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 handle,
                mut id,

            } = slot;
        }

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

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

        Ok(())
    }
}

#[doc = " The information needed to launch a process.\n"]
#[derive(Debug)]
pub struct LaunchInfo {
    pub executable: ::fidl_next::fuchsia::zx::Handle,

    pub job: ::fidl_next::fuchsia::zx::Handle,

    pub name: String,
}

impl ::fidl_next::Encodable for LaunchInfo {
    type Encoded = WireLaunchInfo;
}

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

    ___E: ::fidl_next::Encoder,

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

            } = out;
        }

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

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<LaunchInfo> {
    type EncodedOption = ::fidl_next::WireBox<WireLaunchInfo>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireLaunchInfo> for LaunchInfo {
    #[inline]
    fn take_from(from: &WireLaunchInfo) -> Self {
        Self {
            executable: ::fidl_next::TakeFrom::take_from(&from.executable),

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

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

/// The wire type corresponding to [`LaunchInfo`].
#[derive(Debug)]
#[repr(C)]
pub struct WireLaunchInfo {
    pub executable: ::fidl_next::fuchsia::WireHandle,

    pub job: ::fidl_next::fuchsia::WireHandle,

    pub name: ::fidl_next::WireString,
}

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireLaunchInfo
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 executable,
                mut job,
                mut name,

            } = slot;
        }

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

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

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

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

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

        Ok(())
    }
}

#[derive(Debug)]
pub struct LauncherLaunchRequest {
    pub info: crate::LaunchInfo,
}

impl ::fidl_next::Encodable for LauncherLaunchRequest {
    type Encoded = WireLauncherLaunchRequest;
}

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

    ___E: ::fidl_next::Encoder,

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

            } = out;
        }

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<LauncherLaunchRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireLauncherLaunchRequest>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireLauncherLaunchRequest> for LauncherLaunchRequest {
    #[inline]
    fn take_from(from: &WireLauncherLaunchRequest) -> Self {
        Self { info: ::fidl_next::TakeFrom::take_from(&from.info) }
    }
}

/// The wire type corresponding to [`LauncherLaunchRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireLauncherLaunchRequest {
    pub info: crate::WireLaunchInfo,
}

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

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

            } = slot;
        }

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

        Ok(())
    }
}

#[derive(Debug)]
#[repr(C)]
pub struct LauncherLaunchResponse {
    pub status: i32,

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

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

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

                && <
                    Option<::fidl_next::fuchsia::zx::Handle> as ::fidl_next::Encodable
                >::COPY_OPTIMIZATION.is_enabled()

        )
    };

    type Encoded = WireLauncherLaunchResponse;
}

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

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

            } = out;
        }

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<LauncherLaunchResponse> {
    type EncodedOption = ::fidl_next::WireBox<WireLauncherLaunchResponse>;
}

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

        Ok(())
    }
}

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

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

                && <
                    Option<::fidl_next::fuchsia::zx::Handle> as ::fidl_next::Encodable
                >::COPY_OPTIMIZATION.is_enabled()

        )
    };

    #[inline]
    fn take_from(from: &WireLauncherLaunchResponse) -> Self {
        Self {
            status: ::fidl_next::TakeFrom::take_from(&from.status),

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

/// The wire type corresponding to [`LauncherLaunchResponse`].
#[derive(Debug)]
#[repr(C)]
pub struct WireLauncherLaunchResponse {
    pub status: ::fidl_next::WireI32,

    pub process: ::fidl_next::fuchsia::WireOptionalHandle,
}

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireLauncherLaunchResponse
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 status,
                mut process,

            } = slot;
        }

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

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

        Ok(())
    }
}

#[derive(Debug)]
pub struct LauncherCreateWithoutStartingRequest {
    pub info: crate::LaunchInfo,
}

impl ::fidl_next::Encodable for LauncherCreateWithoutStartingRequest {
    type Encoded = WireLauncherCreateWithoutStartingRequest;
}

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

    ___E: ::fidl_next::Encoder,

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

            } = out;
        }

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<LauncherCreateWithoutStartingRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireLauncherCreateWithoutStartingRequest>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireLauncherCreateWithoutStartingRequest>
    for LauncherCreateWithoutStartingRequest
{
    #[inline]
    fn take_from(from: &WireLauncherCreateWithoutStartingRequest) -> Self {
        Self { info: ::fidl_next::TakeFrom::take_from(&from.info) }
    }
}

/// The wire type corresponding to [`LauncherCreateWithoutStartingRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireLauncherCreateWithoutStartingRequest {
    pub info: crate::WireLaunchInfo,
}

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

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

            } = slot;
        }

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

        Ok(())
    }
}

#[derive(Debug)]
pub struct LauncherCreateWithoutStartingResponse {
    pub status: i32,

    pub data: Option<Box<crate::ProcessStartData>>,
}

impl ::fidl_next::Encodable for LauncherCreateWithoutStartingResponse {
    type Encoded = WireLauncherCreateWithoutStartingResponse;
}

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

    ___E: ::fidl_next::Encoder,

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

            } = out;
        }

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<LauncherCreateWithoutStartingResponse> {
    type EncodedOption = ::fidl_next::WireBox<WireLauncherCreateWithoutStartingResponse>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireLauncherCreateWithoutStartingResponse>
    for LauncherCreateWithoutStartingResponse
{
    #[inline]
    fn take_from(from: &WireLauncherCreateWithoutStartingResponse) -> Self {
        Self {
            status: ::fidl_next::TakeFrom::take_from(&from.status),

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

/// The wire type corresponding to [`LauncherCreateWithoutStartingResponse`].
#[derive(Debug)]
#[repr(C)]
pub struct WireLauncherCreateWithoutStartingResponse {
    pub status: ::fidl_next::WireI32,

    pub data: ::fidl_next::WireBox<crate::WireProcessStartData>,
}

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireLauncherCreateWithoutStartingResponse
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 status,
                mut data,

            } = slot;
        }

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

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

        Ok(())
    }
}

#[derive(Clone, Debug)]
pub struct LauncherAddArgsRequest {
    pub args: Vec<Vec<u8>>,
}

impl ::fidl_next::Encodable for LauncherAddArgsRequest {
    type Encoded = WireLauncherAddArgsRequest;
}

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

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

            } = out;
        }

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<LauncherAddArgsRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireLauncherAddArgsRequest>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireLauncherAddArgsRequest> for LauncherAddArgsRequest {
    #[inline]
    fn take_from(from: &WireLauncherAddArgsRequest) -> Self {
        Self { args: ::fidl_next::TakeFrom::take_from(&from.args) }
    }
}

/// The wire type corresponding to [`LauncherAddArgsRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireLauncherAddArgsRequest {
    pub args: ::fidl_next::WireVector<::fidl_next::WireVector<u8>>,
}

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

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

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

            } = slot;
        }

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

        Ok(())
    }
}

#[derive(Clone, Debug)]
pub struct LauncherAddEnvironsRequest {
    pub environ: Vec<Vec<u8>>,
}

impl ::fidl_next::Encodable for LauncherAddEnvironsRequest {
    type Encoded = WireLauncherAddEnvironsRequest;
}

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

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

            } = out;
        }

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<LauncherAddEnvironsRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireLauncherAddEnvironsRequest>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireLauncherAddEnvironsRequest> for LauncherAddEnvironsRequest {
    #[inline]
    fn take_from(from: &WireLauncherAddEnvironsRequest) -> Self {
        Self { environ: ::fidl_next::TakeFrom::take_from(&from.environ) }
    }
}

/// The wire type corresponding to [`LauncherAddEnvironsRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireLauncherAddEnvironsRequest {
    pub environ: ::fidl_next::WireVector<::fidl_next::WireVector<u8>>,
}

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

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

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

            } = slot;
        }

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

        Ok(())
    }
}

#[derive(Debug)]
pub struct LauncherAddHandlesRequest {
    pub handles: Vec<crate::HandleInfo>,
}

impl ::fidl_next::Encodable for LauncherAddHandlesRequest {
    type Encoded = WireLauncherAddHandlesRequest;
}

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

    ___E: ::fidl_next::Encoder,

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

            } = out;
        }

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<LauncherAddHandlesRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireLauncherAddHandlesRequest>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireLauncherAddHandlesRequest> for LauncherAddHandlesRequest {
    #[inline]
    fn take_from(from: &WireLauncherAddHandlesRequest) -> Self {
        Self { handles: ::fidl_next::TakeFrom::take_from(&from.handles) }
    }
}

/// The wire type corresponding to [`LauncherAddHandlesRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireLauncherAddHandlesRequest {
    pub handles: ::fidl_next::WireVector<crate::WireHandleInfo>,
}

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

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

            } = slot;
        }

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

        Ok(())
    }
}

#[derive(Clone, Debug)]
#[repr(C)]
pub struct LauncherSetOptionsRequest {
    pub options: u32,
}

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

    type Encoded = WireLauncherSetOptionsRequest;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for LauncherSetOptionsRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                options,

            } = out;
        }

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<LauncherSetOptionsRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireLauncherSetOptionsRequest>;
}

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

        Ok(())
    }
}

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

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

/// The wire type corresponding to [`LauncherSetOptionsRequest`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireLauncherSetOptionsRequest {
    pub options: ::fidl_next::WireU32,
}

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireLauncherSetOptionsRequest
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut options,

            } = slot;
        }

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

        Ok(())
    }
}

#[doc = " A namespace entry provided to a process at startup.\n\n Processes are given a set of initial handles as part of the bootstrapping\n sequence. Some of these handles are associated with paths that designate\n their intended use by the new process as namespace entries.\n\n This structure represents one such handle and its associated namespace path.\n"]
#[derive(Debug)]
pub struct NameInfo {
    pub path: String,

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

impl ::fidl_next::Encodable for NameInfo {
    type Encoded = WireNameInfo;
}

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

    ___E: ::fidl_next::Encoder,

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

            } = out;
        }

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<NameInfo> {
    type EncodedOption = ::fidl_next::WireBox<WireNameInfo>;
}

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

        Ok(())
    }
}

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

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

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

    pub directory: ::fidl_next::ClientEnd<
        ::fidl_next::fuchsia::WireChannel,
        ::fidl_next_fuchsia_io::Directory,
    >,
}

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

    ___D: ::fidl_next::Decoder,

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

            } = slot;
        }

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

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

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

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

        Ok(())
    }
}

#[derive(Debug)]
pub struct LauncherAddNamesRequest {
    pub names: Vec<crate::NameInfo>,
}

impl ::fidl_next::Encodable for LauncherAddNamesRequest {
    type Encoded = WireLauncherAddNamesRequest;
}

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

    ___E: ::fidl_next::Encoder,

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

            } = out;
        }

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<LauncherAddNamesRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireLauncherAddNamesRequest>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireLauncherAddNamesRequest> for LauncherAddNamesRequest {
    #[inline]
    fn take_from(from: &WireLauncherAddNamesRequest) -> Self {
        Self { names: ::fidl_next::TakeFrom::take_from(&from.names) }
    }
}

/// The wire type corresponding to [`LauncherAddNamesRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireLauncherAddNamesRequest {
    pub names: ::fidl_next::WireVector<crate::WireNameInfo>,
}

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

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

            } = slot;
        }

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

        Ok(())
    }
}

/// The type corresponding to the Launcher protocol.
#[doc = " A low-level interface for launching processes.\n\n This interface is used for manually assembling a process. The caller supplies\n all the capabilities for the newly created process.\n\n That create processes typically use `fdio_spawn` or `fdio_spawn_etc` rather\n than using this interface directly. The `fdio_spawn` and `fdio_spawn_etc`\n functions are implemented using this interface.\n\n Debuggers and other clients that need to create processes in a suspended\n state often use this interface directly. These clients use the\n `CreateWithoutStarting` method to create the process without actually\n starting it.\n"]
#[derive(Debug)]
pub struct Launcher;

impl ::fidl_next::Discoverable for Launcher {
    const PROTOCOL_NAME: &'static str = "launcher";
}

pub mod launcher {
    pub mod prelude {
        pub use crate::{
            launcher, Launcher, LauncherClientHandler, LauncherClientSender, LauncherServerHandler,
            LauncherServerSender,
        };

        pub use crate::LauncherAddArgsRequest;

        pub use crate::LauncherAddEnvironsRequest;

        pub use crate::LauncherAddHandlesRequest;

        pub use crate::LauncherAddNamesRequest;

        pub use crate::LauncherCreateWithoutStartingRequest;

        pub use crate::LauncherCreateWithoutStartingResponse;

        pub use crate::LauncherLaunchRequest;

        pub use crate::LauncherLaunchResponse;

        pub use crate::LauncherSetOptionsRequest;
    }

    pub struct Launch;

    impl ::fidl_next::Method for Launch {
        const ORDINAL: u64 = 1239433936316120996;

        type Protocol = crate::Launcher;

        type Request = crate::WireLauncherLaunchRequest;

        type Response = crate::WireLauncherLaunchResponse;
    }

    pub struct CreateWithoutStarting;

    impl ::fidl_next::Method for CreateWithoutStarting {
        const ORDINAL: u64 = 8457621991205227361;

        type Protocol = crate::Launcher;

        type Request = crate::WireLauncherCreateWithoutStartingRequest;

        type Response = crate::WireLauncherCreateWithoutStartingResponse;
    }

    pub struct AddArgs;

    impl ::fidl_next::Method for AddArgs {
        const ORDINAL: u64 = 4315651119310005522;

        type Protocol = crate::Launcher;

        type Request = crate::WireLauncherAddArgsRequest;

        type Response = ::fidl_next::Never;
    }

    pub struct AddEnvirons;

    impl ::fidl_next::Method for AddEnvirons {
        const ORDINAL: u64 = 8332725285682026361;

        type Protocol = crate::Launcher;

        type Request = crate::WireLauncherAddEnvironsRequest;

        type Response = ::fidl_next::Never;
    }

    pub struct AddNames;

    impl ::fidl_next::Method for AddNames {
        const ORDINAL: u64 = 2700451326409737826;

        type Protocol = crate::Launcher;

        type Request = crate::WireLauncherAddNamesRequest;

        type Response = ::fidl_next::Never;
    }

    pub struct AddHandles;

    impl ::fidl_next::Method for AddHandles {
        const ORDINAL: u64 = 5837318672132580885;

        type Protocol = crate::Launcher;

        type Request = crate::WireLauncherAddHandlesRequest;

        type Response = ::fidl_next::Never;
    }

    pub struct SetOptions;

    impl ::fidl_next::Method for SetOptions {
        const ORDINAL: u64 = 6598432479381290375;

        type Protocol = crate::Launcher;

        type Request = crate::WireLauncherSetOptionsRequest;

        type Response = ::fidl_next::Never;
    }
}

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

    #[doc = " Creates and starts the process described by `info`.\n\n After processing this message, the `Launcher` is reset to its initial\n state and is ready to launch another process.\n\n `process` is present if, and only if, `status` is `ZX_OK`.\n"]
    fn launch<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, launcher::Launch>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireLauncherLaunchRequest,
        >;

    #[doc = " Creates the process described by `info` but does not start it.\n\n After processing this message, the `Launcher` is reset to its initial\n state and is ready to launch another process.\n\n The caller is responsible for calling `zx_process_start` using the data\n in `ProcessStartData` to actually start the process.\n\n `data` is present if, and only if, `status` is `ZX_OK`.\n"]
    fn create_without_starting<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, launcher::CreateWithoutStarting>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireLauncherCreateWithoutStartingRequest,
        >;

    #[doc = " Adds the given arguments to the command-line for the process.\n\n Calling this method multiple times concatenates the arguments.\n"]
    fn add_args<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireLauncherAddArgsRequest,
        >;

    #[doc = " Adds the given variables to the environment variables for the process.\n\n Calling this method multiple times concatenates the variables.\n"]
    fn add_environs<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireLauncherAddEnvironsRequest,
        >;

    #[doc = " Adds the given names to the namespace for the process.\n\n The paths in the namespace must be non-overlapping. See\n <https://fuchsia.dev/fuchsia-src/concepts/process/namespaces> for details.\n\n Calling this method multiple times concatenates the names.\n"]
    fn add_names<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireLauncherAddNamesRequest,
        >;

    #[doc = " Adds the given handles to the startup handles for the process.\n\n Calling this method multiple times concatenates the handles.\n"]
    fn add_handles<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireLauncherAddHandlesRequest,
        >;

    #[doc = " Sets the options with which the process is created.\n\n Calling this method multiple times will overwrite the current options.\n"]
    fn set_options<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireLauncherSetOptionsRequest,
        >;
}

impl<___T> LauncherClientSender for ::fidl_next::ClientSender<___T, Launcher>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;

    #[doc = " Creates and starts the process described by `info`.\n\n After processing this message, the `Launcher` is reset to its initial\n state and is ready to launch another process.\n\n `process` is present if, and only if, `status` is `ZX_OK`.\n"]
    fn launch<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, launcher::Launch>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireLauncherLaunchRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(1239433936316120996, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Creates the process described by `info` but does not start it.\n\n After processing this message, the `Launcher` is reset to its initial\n state and is ready to launch another process.\n\n The caller is responsible for calling `zx_process_start` using the data\n in `ProcessStartData` to actually start the process.\n\n `data` is present if, and only if, `status` is `ZX_OK`.\n"]
    fn create_without_starting<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, launcher::CreateWithoutStarting>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireLauncherCreateWithoutStartingRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(8457621991205227361, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }

    #[doc = " Adds the given arguments to the command-line for the process.\n\n Calling this method multiple times concatenates the arguments.\n"]
    fn add_args<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireLauncherAddArgsRequest,
        >,
    {
        self.as_untyped().send_one_way(4315651119310005522, request)
    }

    #[doc = " Adds the given variables to the environment variables for the process.\n\n Calling this method multiple times concatenates the variables.\n"]
    fn add_environs<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireLauncherAddEnvironsRequest,
        >,
    {
        self.as_untyped().send_one_way(8332725285682026361, request)
    }

    #[doc = " Adds the given names to the namespace for the process.\n\n The paths in the namespace must be non-overlapping. See\n <https://fuchsia.dev/fuchsia-src/concepts/process/namespaces> for details.\n\n Calling this method multiple times concatenates the names.\n"]
    fn add_names<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireLauncherAddNamesRequest,
        >,
    {
        self.as_untyped().send_one_way(2700451326409737826, request)
    }

    #[doc = " Adds the given handles to the startup handles for the process.\n\n Calling this method multiple times concatenates the handles.\n"]
    fn add_handles<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireLauncherAddHandlesRequest,
        >,
    {
        self.as_untyped().send_one_way(5837318672132580885, request)
    }

    #[doc = " Sets the options with which the process is created.\n\n Calling this method multiple times will overwrite the current options.\n"]
    fn set_options<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireLauncherSetOptionsRequest,
        >,
    {
        self.as_untyped().send_one_way(6598432479381290375, request)
    }
}

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

impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for Launcher
where
    ___T: ::fidl_next::Transport,
    ___H: LauncherClientHandler<___T>,

    <launcher::Launch as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,

    <launcher::CreateWithoutStarting as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    fn on_event(
        handler: &mut ___H,
        sender: &::fidl_next::ClientSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => {
                sender.close();
            }
        }
    }
}

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

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

/// A server handler for the Launcher protocol.
///
/// See [`Launcher`] for more details.
pub trait LauncherServerHandler<___T: ::fidl_next::Transport> {
    #[doc = " Creates and starts the process described by `info`.\n\n After processing this message, the `Launcher` is reset to its initial\n state and is ready to launch another process.\n\n `process` is present if, and only if, `status` is `ZX_OK`.\n"]
    fn launch(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Launcher>,

        request: ::fidl_next::RequestBuffer<___T, launcher::Launch>,

        responder: ::fidl_next::Responder<launcher::Launch>,
    );

    #[doc = " Creates the process described by `info` but does not start it.\n\n After processing this message, the `Launcher` is reset to its initial\n state and is ready to launch another process.\n\n The caller is responsible for calling `zx_process_start` using the data\n in `ProcessStartData` to actually start the process.\n\n `data` is present if, and only if, `status` is `ZX_OK`.\n"]
    fn create_without_starting(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Launcher>,

        request: ::fidl_next::RequestBuffer<___T, launcher::CreateWithoutStarting>,

        responder: ::fidl_next::Responder<launcher::CreateWithoutStarting>,
    );

    #[doc = " Adds the given arguments to the command-line for the process.\n\n Calling this method multiple times concatenates the arguments.\n"]
    fn add_args(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Launcher>,

        request: ::fidl_next::RequestBuffer<___T, launcher::AddArgs>,
    );

    #[doc = " Adds the given variables to the environment variables for the process.\n\n Calling this method multiple times concatenates the variables.\n"]
    fn add_environs(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Launcher>,

        request: ::fidl_next::RequestBuffer<___T, launcher::AddEnvirons>,
    );

    #[doc = " Adds the given names to the namespace for the process.\n\n The paths in the namespace must be non-overlapping. See\n <https://fuchsia.dev/fuchsia-src/concepts/process/namespaces> for details.\n\n Calling this method multiple times concatenates the names.\n"]
    fn add_names(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Launcher>,

        request: ::fidl_next::RequestBuffer<___T, launcher::AddNames>,
    );

    #[doc = " Adds the given handles to the startup handles for the process.\n\n Calling this method multiple times concatenates the handles.\n"]
    fn add_handles(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Launcher>,

        request: ::fidl_next::RequestBuffer<___T, launcher::AddHandles>,
    );

    #[doc = " Sets the options with which the process is created.\n\n Calling this method multiple times will overwrite the current options.\n"]
    fn set_options(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Launcher>,

        request: ::fidl_next::RequestBuffer<___T, launcher::SetOptions>,
    );
}

impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for Launcher
where
    ___T: ::fidl_next::Transport,
    ___H: LauncherServerHandler<___T>,

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

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

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

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

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

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

    crate::WireLauncherSetOptionsRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            4315651119310005522 => {
                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.add_args(sender, buffer);
            }

            8332725285682026361 => {
                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.add_environs(sender, buffer);
            }

            2700451326409737826 => {
                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.add_names(sender, buffer);
            }

            5837318672132580885 => {
                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.add_handles(sender, buffer);
            }

            6598432479381290375 => {
                let buffer = ::fidl_next::RequestBuffer::from_untyped(buffer);
                handler.set_options(sender, buffer);
            }

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

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

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

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

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

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

#[doc = " The maximum size for a name used by `Resolver`.\n"]
pub const MAX_RESOLVE_NAME_SIZE: u32 = 2048;

#[doc = " The information required to start a process.\n\n To start the process, call `zx_process_start` with the arguments provided.\n"]
#[derive(Debug)]
pub struct ProcessStartData {
    pub process: ::fidl_next::fuchsia::zx::Handle,

    pub root_vmar: ::fidl_next::fuchsia::zx::Handle,

    pub thread: ::fidl_next::fuchsia::zx::Handle,

    pub entry: u64,

    pub stack: u64,

    pub bootstrap: ::fidl_next::fuchsia::zx::Handle,

    pub vdso_base: u64,

    pub base: u64,
}

impl ::fidl_next::Encodable for ProcessStartData {
    type Encoded = WireProcessStartData;
}

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

    ___E: ::fidl_next::fuchsia::HandleEncoder,
{
    #[inline]
    fn encode(
        &mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                process,
                root_vmar,
                thread,
                entry,
                stack,
                bootstrap,
                vdso_base,
                base,

            } = out;
        }

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

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

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

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

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

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

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<ProcessStartData> {
    type EncodedOption = ::fidl_next::WireBox<WireProcessStartData>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireProcessStartData> for ProcessStartData {
    #[inline]
    fn take_from(from: &WireProcessStartData) -> Self {
        Self {
            process: ::fidl_next::TakeFrom::take_from(&from.process),

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

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

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

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

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

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

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

/// The wire type corresponding to [`ProcessStartData`].
#[derive(Debug)]
#[repr(C)]
pub struct WireProcessStartData {
    pub process: ::fidl_next::fuchsia::WireHandle,

    pub root_vmar: ::fidl_next::fuchsia::WireHandle,

    pub thread: ::fidl_next::fuchsia::WireHandle,

    pub entry: ::fidl_next::WireU64,

    pub stack: ::fidl_next::WireU64,

    pub bootstrap: ::fidl_next::fuchsia::WireHandle,

    pub vdso_base: ::fidl_next::WireU64,

    pub base: ::fidl_next::WireU64,
}

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

        unsafe {
            out.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
        }
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireProcessStartData
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 process,
                mut root_vmar,
                mut thread,
                mut entry,
                mut stack,
                mut bootstrap,
                mut vdso_base,
                mut base,

            } = slot;
        }

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

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

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

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

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

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

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

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

        Ok(())
    }
}

#[derive(Clone, Debug)]
pub struct ResolverResolveRequest {
    pub name: String,
}

impl ::fidl_next::Encodable for ResolverResolveRequest {
    type Encoded = WireResolverResolveRequest;
}

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

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

            } = out;
        }

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<ResolverResolveRequest> {
    type EncodedOption = ::fidl_next::WireBox<WireResolverResolveRequest>;
}

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

        Ok(())
    }
}

impl ::fidl_next::TakeFrom<WireResolverResolveRequest> for ResolverResolveRequest {
    #[inline]
    fn take_from(from: &WireResolverResolveRequest) -> Self {
        Self { name: ::fidl_next::TakeFrom::take_from(&from.name) }
    }
}

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

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

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

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

            } = slot;
        }

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

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

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

        Ok(())
    }
}

#[derive(Debug)]
#[repr(C)]
pub struct ResolverResolveResponse {
    pub status: i32,

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

    pub ldsvc: ::fidl_next::ClientEnd<
        Option<::fidl_next::fuchsia::zx::Channel>,
        ::fidl_next_fuchsia_ldsvc::Loader,
    >,
}

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

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

                && <
                    Option<::fidl_next::fuchsia::zx::Handle> as ::fidl_next::Encodable
                >::COPY_OPTIMIZATION.is_enabled()

                && <
                    ::fidl_next::ClientEnd<Option<::fidl_next::fuchsia::zx::Channel>,::fidl_next_fuchsia_ldsvc::Loader,
        > as ::fidl_next::Encodable
                >::COPY_OPTIMIZATION.is_enabled()

        )
    };

    type Encoded = WireResolverResolveResponse;
}

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

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

            } = out;
        }

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

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

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

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for Box<ResolverResolveResponse> {
    type EncodedOption = ::fidl_next::WireBox<WireResolverResolveResponse>;
}

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

        Ok(())
    }
}

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

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

                && <
                    Option<::fidl_next::fuchsia::zx::Handle> as ::fidl_next::Encodable
                >::COPY_OPTIMIZATION.is_enabled()

                && <
                    ::fidl_next::ClientEnd<Option<::fidl_next::fuchsia::zx::Channel>,::fidl_next_fuchsia_ldsvc::Loader,
        > as ::fidl_next::Encodable
                >::COPY_OPTIMIZATION.is_enabled()

        )
    };

    #[inline]
    fn take_from(from: &WireResolverResolveResponse) -> Self {
        Self {
            status: ::fidl_next::TakeFrom::take_from(&from.status),

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

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

/// The wire type corresponding to [`ResolverResolveResponse`].
#[derive(Debug)]
#[repr(C)]
pub struct WireResolverResolveResponse {
    pub status: ::fidl_next::WireI32,

    pub executable: ::fidl_next::fuchsia::WireOptionalHandle,

    pub ldsvc: ::fidl_next::ClientEnd<
        ::fidl_next::fuchsia::WireOptionalChannel,
        ::fidl_next_fuchsia_ldsvc::Loader,
    >,
}

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireResolverResolveResponse
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 status,
                mut executable,
                mut ldsvc,

            } = slot;
        }

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

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

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

        Ok(())
    }
}

/// The type corresponding to the Resolver protocol.
#[doc = " An interface for resolving names to executables and library loaders.\n\n An executable itself is often not sufficient to create a working process\n because many executables also load shared libraries. On Fuchsia, there is no\n global pool of shared libraries. Instead, every process has an associated\n `fuchsia.ldsvc.Loader`, which provides access to a private pool of shared\n libraries appropriate for that process.\n\n This interface provides a protocol for resolving a name into both the\n `zx.Handle:VMO` for the executable and the `fuchsia.ldsvc.Loader` for its\n associated shared libraries.\n\n This interface is rarely used directly. Instead, `fdio_spawn` and\n `fdio_spawn_etc` use this interface internally when they try to run a file\n with a `#!resolve` directive.\n"]
#[derive(Debug)]
pub struct Resolver;

impl ::fidl_next::Discoverable for Resolver {
    const PROTOCOL_NAME: &'static str = "resolver";
}

pub mod resolver {
    pub mod prelude {
        pub use crate::{
            resolver, Resolver, ResolverClientHandler, ResolverClientSender, ResolverServerHandler,
            ResolverServerSender,
        };

        pub use crate::ResolverResolveRequest;

        pub use crate::ResolverResolveResponse;
    }

    pub struct Resolve;

    impl ::fidl_next::Method for Resolve {
        const ORDINAL: u64 = 4329530577128037520;

        type Protocol = crate::Resolver;

        type Request = crate::WireResolverResolveRequest;

        type Response = crate::WireResolverResolveResponse;
    }
}

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

    #[doc = " Resolves the given `name` to an `executable` and an shared library\n loader.\n\n If present, the `executable` is suitable for use as the `executable`\n property of `LaunchInfo` -- in particular, it will have `ZX_RIGHT_EXECUTE`.\n If present, the `ldsvc` is suitable for use as the `PA_LDSVC_LOADER`\n handle when launching the process.\n\n For example, the resolver might locate the given `name` inside a package\n and return the executable binary from the package as well as a shared\n library loader scoped to that package.\n"]
    fn resolve<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, resolver::Resolve>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireResolverResolveRequest,
        >;
}

impl<___T> ResolverClientSender for ::fidl_next::ClientSender<___T, Resolver>
where
    ___T: ::fidl_next::Transport,
{
    type Transport = ___T;

    #[doc = " Resolves the given `name` to an `executable` and an shared library\n loader.\n\n If present, the `executable` is suitable for use as the `executable`\n property of `LaunchInfo` -- in particular, it will have `ZX_RIGHT_EXECUTE`.\n If present, the `ldsvc` is suitable for use as the `PA_LDSVC_LOADER`\n handle when launching the process.\n\n For example, the resolver might locate the given `name` inside a package\n and return the executable binary from the package as well as a shared\n library loader scoped to that package.\n"]
    fn resolve<___R>(
        &self,
        request: &mut ___R,
    ) -> Result<
        ::fidl_next::ResponseFuture<'_, Self::Transport, resolver::Resolve>,
        ::fidl_next::EncodeError,
    >
    where
        ___R: ::fidl_next::Encode<
            <Self::Transport as ::fidl_next::Transport>::SendBuffer,
            Encoded = crate::WireResolverResolveRequest,
        >,
    {
        self.as_untyped()
            .send_two_way(4329530577128037520, request)
            .map(::fidl_next::ResponseFuture::from_untyped)
    }
}

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

impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for Resolver
where
    ___T: ::fidl_next::Transport,
    ___H: ResolverClientHandler<___T>,

    <resolver::Resolve as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    fn on_event(
        handler: &mut ___H,
        sender: &::fidl_next::ClientSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => {
                sender.close();
            }
        }
    }
}

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

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

/// A server handler for the Resolver protocol.
///
/// See [`Resolver`] for more details.
pub trait ResolverServerHandler<___T: ::fidl_next::Transport> {
    #[doc = " Resolves the given `name` to an `executable` and an shared library\n loader.\n\n If present, the `executable` is suitable for use as the `executable`\n property of `LaunchInfo` -- in particular, it will have `ZX_RIGHT_EXECUTE`.\n If present, the `ldsvc` is suitable for use as the `PA_LDSVC_LOADER`\n handle when launching the process.\n\n For example, the resolver might locate the given `name` inside a package\n and return the executable binary from the package as well as a shared\n library loader scoped to that package.\n"]
    fn resolve(
        &mut self,
        sender: &::fidl_next::ServerSender<___T, Resolver>,

        request: ::fidl_next::RequestBuffer<___T, resolver::Resolve>,

        responder: ::fidl_next::Responder<resolver::Resolve>,
    );
}

impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for Resolver
where
    ___T: ::fidl_next::Transport,
    ___H: ResolverServerHandler<___T>,

    crate::WireResolverResolveRequest:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<___T, Self>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => {
                sender.close();
            }
        }
    }

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

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

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

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

    impl ::fidl_next::TakeFrom<crate::WireHandleInfo> for ::fidl_fuchsia_process::HandleInfo {
        #[inline]
        fn take_from(from: &crate::WireHandleInfo) -> Self {
            Self {
                handle: ::fidl_next::TakeFrom::take_from(&from.handle),

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

    impl ::fidl_next::TakeFrom<crate::WireLaunchInfo> for ::fidl_fuchsia_process::LaunchInfo {
        #[inline]
        fn take_from(from: &crate::WireLaunchInfo) -> Self {
            Self {
                executable: ::fidl_next::TakeFrom::take_from(&from.executable),

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

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

    impl ::fidl_next::TakeFrom<crate::WireLauncherLaunchRequest>
        for ::fidl_fuchsia_process::LauncherLaunchRequest
    {
        #[inline]
        fn take_from(from: &crate::WireLauncherLaunchRequest) -> Self {
            Self { info: ::fidl_next::TakeFrom::take_from(&from.info) }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireLauncherLaunchResponse>
        for ::fidl_fuchsia_process::LauncherLaunchResponse
    {
        #[inline]
        fn take_from(from: &crate::WireLauncherLaunchResponse) -> Self {
            Self {
                status: ::fidl_next::TakeFrom::take_from(&from.status),

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

    impl ::fidl_next::TakeFrom<crate::WireLauncherCreateWithoutStartingRequest>
        for ::fidl_fuchsia_process::LauncherCreateWithoutStartingRequest
    {
        #[inline]
        fn take_from(from: &crate::WireLauncherCreateWithoutStartingRequest) -> Self {
            Self { info: ::fidl_next::TakeFrom::take_from(&from.info) }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireLauncherCreateWithoutStartingResponse>
        for ::fidl_fuchsia_process::LauncherCreateWithoutStartingResponse
    {
        #[inline]
        fn take_from(from: &crate::WireLauncherCreateWithoutStartingResponse) -> Self {
            Self {
                status: ::fidl_next::TakeFrom::take_from(&from.status),

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

    impl ::fidl_next::TakeFrom<crate::WireLauncherAddArgsRequest>
        for ::fidl_fuchsia_process::LauncherAddArgsRequest
    {
        #[inline]
        fn take_from(from: &crate::WireLauncherAddArgsRequest) -> Self {
            Self { args: ::fidl_next::TakeFrom::take_from(&from.args) }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireLauncherAddEnvironsRequest>
        for ::fidl_fuchsia_process::LauncherAddEnvironsRequest
    {
        #[inline]
        fn take_from(from: &crate::WireLauncherAddEnvironsRequest) -> Self {
            Self { environ: ::fidl_next::TakeFrom::take_from(&from.environ) }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireLauncherAddHandlesRequest>
        for ::fidl_fuchsia_process::LauncherAddHandlesRequest
    {
        #[inline]
        fn take_from(from: &crate::WireLauncherAddHandlesRequest) -> Self {
            Self { handles: ::fidl_next::TakeFrom::take_from(&from.handles) }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireLauncherSetOptionsRequest>
        for ::fidl_fuchsia_process::LauncherSetOptionsRequest
    {
        #[inline]
        fn take_from(from: &crate::WireLauncherSetOptionsRequest) -> Self {
            Self { options: ::fidl_next::TakeFrom::take_from(&from.options) }
        }
    }

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

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

    impl ::fidl_next::TakeFrom<crate::WireLauncherAddNamesRequest>
        for ::fidl_fuchsia_process::LauncherAddNamesRequest
    {
        #[inline]
        fn take_from(from: &crate::WireLauncherAddNamesRequest) -> Self {
            Self { names: ::fidl_next::TakeFrom::take_from(&from.names) }
        }
    }

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

    impl ::fidl_next::TakeFrom<crate::Launcher> for ::fidl_fuchsia_process::LauncherMarker {
        #[inline]
        fn take_from(from: &crate::Launcher) -> Self {
            Self
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireProcessStartData>
        for ::fidl_fuchsia_process::ProcessStartData
    {
        #[inline]
        fn take_from(from: &crate::WireProcessStartData) -> Self {
            Self {
                process: ::fidl_next::TakeFrom::take_from(&from.process),

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

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

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

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

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

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

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

    impl ::fidl_next::TakeFrom<crate::WireResolverResolveRequest>
        for ::fidl_fuchsia_process::ResolverResolveRequest
    {
        #[inline]
        fn take_from(from: &crate::WireResolverResolveRequest) -> Self {
            Self { name: ::fidl_next::TakeFrom::take_from(&from.name) }
        }
    }

    impl ::fidl_next::TakeFrom<crate::WireResolverResolveResponse>
        for ::fidl_fuchsia_process::ResolverResolveResponse
    {
        #[inline]
        fn take_from(from: &crate::WireResolverResolveResponse) -> Self {
            Self {
                status: ::fidl_next::TakeFrom::take_from(&from.status),

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

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

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

    impl ::fidl_next::TakeFrom<crate::Resolver> for ::fidl_fuchsia_process::ResolverMarker {
        #[inline]
        fn take_from(from: &crate::Resolver) -> Self {
            Self
        }
    }
}