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(PartialEq, 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, WireHandleInfo> = 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(
        self,
        encoder_: &mut ___E,
        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                handle,
                id,

            } = out_;
        }

        ::fidl_next::Encode::encode(self.handle, encoder_, handle)?;

        ::fidl_next::Encode::encode(self.id, encoder_, id)?;

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for HandleInfo
where
    ___E: ::fidl_next::Encoder + ?Sized,
    HandleInfo: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: ::core::option::Option<Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> ::core::result::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<WireHandleInfo> for HandleInfo {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireHandleInfo, 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()
                && <u32 as ::fidl_next::FromWire<::fidl_next::WireU32>>::COPY_OPTIMIZATION
                    .is_enabled(),
        )
    };

    #[inline]
    fn from_wire(wire: WireHandleInfo) -> Self {
        Self {
            handle: ::fidl_next::FromWire::from_wire(wire.handle),

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

impl ::fidl_next::IntoNatural for WireHandleInfo {
    type Natural = HandleInfo;
}

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

    pub id: ::fidl_next::WireU32,
}
static_assertions::const_assert_eq!(std::mem::size_of::<WireHandleInfo>(), 8);
static_assertions::const_assert_eq!(std::mem::align_of::<WireHandleInfo>(), 4);

static_assertions::const_assert_eq!(std::mem::offset_of!(WireHandleInfo, handle), 0);

static_assertions::const_assert_eq!(std::mem::offset_of!(WireHandleInfo, id), 4);

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

    #[inline]
    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge! {
            let Self {

                handle,
                id,

            } = &mut *out_;
        }

        ::fidl_next::Wire::zero_padding(handle);

        ::fidl_next::Wire::zero_padding(id);
    }
}

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,
    ) -> ::core::result::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(PartialEq, Debug)]
pub struct LaunchInfo {
    pub executable: ::fidl_next::fuchsia::zx::Vmo,

    pub job: ::fidl_next::fuchsia::zx::Job,

    pub name: ::std::string::String,
}

impl ::fidl_next::Encodable for LaunchInfo {
    type Encoded = WireLaunchInfo<'static>;
}

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(
        self,
        encoder_: &mut ___E,
        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                executable,
                job,
                name,

            } = out_;
        }

        ::fidl_next::Encode::encode(self.executable, encoder_, executable)?;

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

        ::fidl_next::Encode::encode(self.name, encoder_, name)?;

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for LaunchInfo
where
    ___E: ::fidl_next::Encoder + ?Sized,
    LaunchInfo: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: ::core::option::Option<Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> ::core::result::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<WireLaunchInfo<'de>> for LaunchInfo {
    #[inline]
    fn from_wire(wire: WireLaunchInfo<'de>) -> Self {
        Self {
            executable: ::fidl_next::FromWire::from_wire(wire.executable),

            job: ::fidl_next::FromWire::from_wire(wire.job),

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

impl<'de> ::fidl_next::IntoNatural for WireLaunchInfo<'de> {
    type Natural = LaunchInfo;
}

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

    pub job: ::fidl_next::fuchsia::WireJob,

    pub name: ::fidl_next::WireString<'de>,
}
static_assertions::const_assert_eq!(std::mem::size_of::<WireLaunchInfo<'_>>(), 24);
static_assertions::const_assert_eq!(std::mem::align_of::<WireLaunchInfo<'_>>(), 8);

static_assertions::const_assert_eq!(std::mem::offset_of!(WireLaunchInfo<'_>, executable), 0);

static_assertions::const_assert_eq!(std::mem::offset_of!(WireLaunchInfo<'_>, job), 4);

static_assertions::const_assert_eq!(std::mem::offset_of!(WireLaunchInfo<'_>, name), 8);

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

    #[inline]
    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge! {
            let Self {

                executable,
                job,
                name,

            } = &mut *out_;
        }

        ::fidl_next::Wire::zero_padding(executable);

        ::fidl_next::Wire::zero_padding(job);

        ::fidl_next::Wire::zero_padding(name);
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireLaunchInfo<'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,
    ) -> ::core::result::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(PartialEq, Debug)]
pub struct LauncherLaunchRequest {
    pub info: crate::LaunchInfo,
}

impl ::fidl_next::Encodable for LauncherLaunchRequest {
    type Encoded = WireLauncherLaunchRequest<'static>;
}

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(
        self,
        encoder_: &mut ___E,
        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                info,

            } = out_;
        }

        ::fidl_next::Encode::encode(self.info, encoder_, info)?;

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for LauncherLaunchRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    LauncherLaunchRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: ::core::option::Option<Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> ::core::result::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<WireLauncherLaunchRequest<'de>> for LauncherLaunchRequest {
    #[inline]
    fn from_wire(wire: WireLauncherLaunchRequest<'de>) -> Self {
        Self { info: ::fidl_next::FromWire::from_wire(wire.info) }
    }
}

impl<'de> ::fidl_next::IntoNatural for WireLauncherLaunchRequest<'de> {
    type Natural = LauncherLaunchRequest;
}

/// The wire type corresponding to [`LauncherLaunchRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireLauncherLaunchRequest<'de> {
    pub info: crate::WireLaunchInfo<'de>,
}
static_assertions::const_assert_eq!(std::mem::size_of::<WireLauncherLaunchRequest<'_>>(), 24);
static_assertions::const_assert_eq!(std::mem::align_of::<WireLauncherLaunchRequest<'_>>(), 8);

static_assertions::const_assert_eq!(std::mem::offset_of!(WireLauncherLaunchRequest<'_>, info), 0);

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

    #[inline]
    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge! {
            let Self {

                info,

            } = &mut *out_;
        }

        ::fidl_next::Wire::zero_padding(info);
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireLauncherLaunchRequest<'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,
    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {

                mut info,

            } = slot_;
        }

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

        Ok(())
    }
}

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

    pub process: ::core::option::Option<::fidl_next::fuchsia::zx::Process>,
}

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

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

                && <
                    ::core::option::Option<::fidl_next::fuchsia::zx::Process> 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(
        self,
        encoder_: &mut ___E,
        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                status,
                process,

            } = out_;
        }

        ::fidl_next::Encode::encode(self.status, encoder_, status)?;

        ::fidl_next::Encode::encode(self.process, encoder_, process)?;

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for LauncherLaunchResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    LauncherLaunchResponse: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: ::core::option::Option<Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> ::core::result::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<WireLauncherLaunchResponse> for LauncherLaunchResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireLauncherLaunchResponse, Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true

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

                && <
                    ::core::option::Option<::fidl_next::fuchsia::zx::Process> as ::fidl_next::FromWire<::fidl_next::fuchsia::WireOptionalProcess>
                >::COPY_OPTIMIZATION.is_enabled()

        )
    };

    #[inline]
    fn from_wire(wire: WireLauncherLaunchResponse) -> Self {
        Self {
            status: ::fidl_next::FromWire::from_wire(wire.status),

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

impl ::fidl_next::IntoNatural for WireLauncherLaunchResponse {
    type Natural = LauncherLaunchResponse;
}

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

    pub process: ::fidl_next::fuchsia::WireOptionalProcess,
}
static_assertions::const_assert_eq!(std::mem::size_of::<WireLauncherLaunchResponse>(), 8);
static_assertions::const_assert_eq!(std::mem::align_of::<WireLauncherLaunchResponse>(), 4);

static_assertions::const_assert_eq!(std::mem::offset_of!(WireLauncherLaunchResponse, status), 0);

static_assertions::const_assert_eq!(std::mem::offset_of!(WireLauncherLaunchResponse, process), 4);

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

    #[inline]
    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge! {
            let Self {

                status,
                process,

            } = &mut *out_;
        }

        ::fidl_next::Wire::zero_padding(status);

        ::fidl_next::Wire::zero_padding(process);
    }
}

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,
    ) -> ::core::result::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(PartialEq, Debug)]
pub struct LauncherCreateWithoutStartingRequest {
    pub info: crate::LaunchInfo,
}

impl ::fidl_next::Encodable for LauncherCreateWithoutStartingRequest {
    type Encoded = WireLauncherCreateWithoutStartingRequest<'static>;
}

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(
        self,
        encoder_: &mut ___E,
        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                info,

            } = out_;
        }

        ::fidl_next::Encode::encode(self.info, encoder_, info)?;

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for LauncherCreateWithoutStartingRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    LauncherCreateWithoutStartingRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: ::core::option::Option<Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> ::core::result::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<WireLauncherCreateWithoutStartingRequest<'de>>
    for LauncherCreateWithoutStartingRequest
{
    #[inline]
    fn from_wire(wire: WireLauncherCreateWithoutStartingRequest<'de>) -> Self {
        Self { info: ::fidl_next::FromWire::from_wire(wire.info) }
    }
}

impl<'de> ::fidl_next::IntoNatural for WireLauncherCreateWithoutStartingRequest<'de> {
    type Natural = LauncherCreateWithoutStartingRequest;
}

/// The wire type corresponding to [`LauncherCreateWithoutStartingRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireLauncherCreateWithoutStartingRequest<'de> {
    pub info: crate::WireLaunchInfo<'de>,
}
static_assertions::const_assert_eq!(
    std::mem::size_of::<WireLauncherCreateWithoutStartingRequest<'_>>(),
    24
);
static_assertions::const_assert_eq!(
    std::mem::align_of::<WireLauncherCreateWithoutStartingRequest<'_>>(),
    8
);

static_assertions::const_assert_eq!(
    std::mem::offset_of!(WireLauncherCreateWithoutStartingRequest<'_>, info),
    0
);

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

    #[inline]
    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge! {
            let Self {

                info,

            } = &mut *out_;
        }

        ::fidl_next::Wire::zero_padding(info);
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireLauncherCreateWithoutStartingRequest<'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,
    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {

                mut info,

            } = slot_;
        }

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

        Ok(())
    }
}

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

    pub data: ::core::option::Option<::std::boxed::Box<crate::ProcessStartData>>,
}

impl ::fidl_next::Encodable for LauncherCreateWithoutStartingResponse {
    type Encoded = WireLauncherCreateWithoutStartingResponse<'static>;
}

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(
        self,
        encoder_: &mut ___E,
        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                status,
                data,

            } = out_;
        }

        ::fidl_next::Encode::encode(self.status, encoder_, status)?;

        ::fidl_next::Encode::encode(self.data, encoder_, data)?;

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for LauncherCreateWithoutStartingResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    LauncherCreateWithoutStartingResponse: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: ::core::option::Option<Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> ::core::result::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<WireLauncherCreateWithoutStartingResponse<'de>>
    for LauncherCreateWithoutStartingResponse
{
    #[inline]
    fn from_wire(wire: WireLauncherCreateWithoutStartingResponse<'de>) -> Self {
        Self {
            status: ::fidl_next::FromWire::from_wire(wire.status),

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

impl<'de> ::fidl_next::IntoNatural for WireLauncherCreateWithoutStartingResponse<'de> {
    type Natural = LauncherCreateWithoutStartingResponse;
}

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

    pub data: ::fidl_next::WireBox<'de, crate::WireProcessStartData>,
}
static_assertions::const_assert_eq!(
    std::mem::size_of::<WireLauncherCreateWithoutStartingResponse<'_>>(),
    16
);
static_assertions::const_assert_eq!(
    std::mem::align_of::<WireLauncherCreateWithoutStartingResponse<'_>>(),
    8
);

static_assertions::const_assert_eq!(
    std::mem::offset_of!(WireLauncherCreateWithoutStartingResponse<'_>, status),
    0
);

static_assertions::const_assert_eq!(
    std::mem::offset_of!(WireLauncherCreateWithoutStartingResponse<'_>, data),
    8
);

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

    #[inline]
    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge! {
            let Self {

                status,
                data,

            } = &mut *out_;
        }

        ::fidl_next::Wire::zero_padding(status);

        ::fidl_next::Wire::zero_padding(data);

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireLauncherCreateWithoutStartingResponse<'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,
    ) -> ::core::result::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(PartialEq, Clone, Debug)]
pub struct LauncherAddArgsRequest {
    pub args: ::std::vec::Vec<::std::vec::Vec<u8>>,
}

impl ::fidl_next::Encodable for LauncherAddArgsRequest {
    type Encoded = WireLauncherAddArgsRequest<'static>;
}

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

            } = out_;
        }

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

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for LauncherAddArgsRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder_: &mut ___E,
        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {

                args,

            } = out_;
        }

        ::fidl_next::EncodeRef::encode_ref(&self.args, encoder_, args)?;

        Ok(())
    }
}

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

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

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for LauncherAddArgsRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    LauncherAddArgsRequest: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: ::core::option::Option<&Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> ::core::result::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<WireLauncherAddArgsRequest<'de>> for LauncherAddArgsRequest {
    #[inline]
    fn from_wire(wire: WireLauncherAddArgsRequest<'de>) -> Self {
        Self { args: ::fidl_next::FromWire::from_wire(wire.args) }
    }
}

impl<'de> ::fidl_next::IntoNatural for WireLauncherAddArgsRequest<'de> {
    type Natural = LauncherAddArgsRequest;
}

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

/// The wire type corresponding to [`LauncherAddArgsRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireLauncherAddArgsRequest<'de> {
    pub args: ::fidl_next::WireVector<'de, ::fidl_next::WireVector<'de, u8>>,
}
static_assertions::const_assert_eq!(std::mem::size_of::<WireLauncherAddArgsRequest<'_>>(), 16);
static_assertions::const_assert_eq!(std::mem::align_of::<WireLauncherAddArgsRequest<'_>>(), 8);

static_assertions::const_assert_eq!(std::mem::offset_of!(WireLauncherAddArgsRequest<'_>, args), 0);

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

    #[inline]
    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge! {
            let Self {

                args,

            } = &mut *out_;
        }

        ::fidl_next::Wire::zero_padding(args);
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireLauncherAddArgsRequest<'static>
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
    ___D: ::fidl_next::Decoder,
{
    fn decode(
        slot_: ::fidl_next::Slot<'_, Self>,
        decoder_: &mut ___D,
    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {

                mut args,

            } = slot_;
        }

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

        Ok(())
    }
}

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

impl ::fidl_next::Encodable for LauncherAddEnvironsRequest {
    type Encoded = WireLauncherAddEnvironsRequest<'static>;
}

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

            } = out_;
        }

        ::fidl_next::Encode::encode(self.environ, encoder_, environ)?;

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for LauncherAddEnvironsRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder_: &mut ___E,
        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {

                environ,

            } = out_;
        }

        ::fidl_next::EncodeRef::encode_ref(&self.environ, encoder_, environ)?;

        Ok(())
    }
}

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

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

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for LauncherAddEnvironsRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    LauncherAddEnvironsRequest: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: ::core::option::Option<&Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> ::core::result::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<WireLauncherAddEnvironsRequest<'de>>
    for LauncherAddEnvironsRequest
{
    #[inline]
    fn from_wire(wire: WireLauncherAddEnvironsRequest<'de>) -> Self {
        Self { environ: ::fidl_next::FromWire::from_wire(wire.environ) }
    }
}

impl<'de> ::fidl_next::IntoNatural for WireLauncherAddEnvironsRequest<'de> {
    type Natural = LauncherAddEnvironsRequest;
}

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

/// The wire type corresponding to [`LauncherAddEnvironsRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireLauncherAddEnvironsRequest<'de> {
    pub environ: ::fidl_next::WireVector<'de, ::fidl_next::WireVector<'de, u8>>,
}
static_assertions::const_assert_eq!(std::mem::size_of::<WireLauncherAddEnvironsRequest<'_>>(), 16);
static_assertions::const_assert_eq!(std::mem::align_of::<WireLauncherAddEnvironsRequest<'_>>(), 8);

static_assertions::const_assert_eq!(
    std::mem::offset_of!(WireLauncherAddEnvironsRequest<'_>, environ),
    0
);

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

    #[inline]
    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge! {
            let Self {

                environ,

            } = &mut *out_;
        }

        ::fidl_next::Wire::zero_padding(environ);
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireLauncherAddEnvironsRequest<'static>
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
    ___D: ::fidl_next::Decoder,
{
    fn decode(
        slot_: ::fidl_next::Slot<'_, Self>,
        decoder_: &mut ___D,
    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {

                mut environ,

            } = slot_;
        }

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

        Ok(())
    }
}

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

impl ::fidl_next::Encodable for LauncherAddHandlesRequest {
    type Encoded = WireLauncherAddHandlesRequest<'static>;
}

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(
        self,
        encoder_: &mut ___E,
        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                handles,

            } = out_;
        }

        ::fidl_next::Encode::encode(self.handles, encoder_, handles)?;

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for LauncherAddHandlesRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    LauncherAddHandlesRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: ::core::option::Option<Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> ::core::result::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<WireLauncherAddHandlesRequest<'de>> for LauncherAddHandlesRequest {
    #[inline]
    fn from_wire(wire: WireLauncherAddHandlesRequest<'de>) -> Self {
        Self { handles: ::fidl_next::FromWire::from_wire(wire.handles) }
    }
}

impl<'de> ::fidl_next::IntoNatural for WireLauncherAddHandlesRequest<'de> {
    type Natural = LauncherAddHandlesRequest;
}

/// The wire type corresponding to [`LauncherAddHandlesRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireLauncherAddHandlesRequest<'de> {
    pub handles: ::fidl_next::WireVector<'de, crate::WireHandleInfo>,
}
static_assertions::const_assert_eq!(std::mem::size_of::<WireLauncherAddHandlesRequest<'_>>(), 16);
static_assertions::const_assert_eq!(std::mem::align_of::<WireLauncherAddHandlesRequest<'_>>(), 8);

static_assertions::const_assert_eq!(
    std::mem::offset_of!(WireLauncherAddHandlesRequest<'_>, handles),
    0
);

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

    #[inline]
    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge! {
            let Self {

                handles,

            } = &mut *out_;
        }

        ::fidl_next::Wire::zero_padding(handles);
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireLauncherAddHandlesRequest<'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,
    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {

                mut handles,

            } = slot_;
        }

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

        Ok(())
    }
}

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

impl ::fidl_next::Encodable for LauncherSetOptionsRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireLauncherSetOptionsRequest> = 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(
        self,
        encoder_: &mut ___E,
        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                options,

            } = out_;
        }

        ::fidl_next::Encode::encode(self.options, encoder_, options)?;

        Ok(())
    }
}

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

                options,

            } = out_;
        }

        ::fidl_next::EncodeRef::encode_ref(&self.options, encoder_, options)?;

        Ok(())
    }
}

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

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

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for LauncherSetOptionsRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    LauncherSetOptionsRequest: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: ::core::option::Option<&Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> ::core::result::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<WireLauncherSetOptionsRequest> for LauncherSetOptionsRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireLauncherSetOptionsRequest, Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <u32 as ::fidl_next::FromWire<::fidl_next::WireU32>>::COPY_OPTIMIZATION
                .is_enabled(),
        )
    };

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

impl ::fidl_next::IntoNatural for WireLauncherSetOptionsRequest {
    type Natural = LauncherSetOptionsRequest;
}

impl ::fidl_next::FromWireRef<WireLauncherSetOptionsRequest> for LauncherSetOptionsRequest {
    #[inline]
    fn from_wire_ref(wire: &WireLauncherSetOptionsRequest) -> Self {
        Self { options: ::fidl_next::FromWireRef::from_wire_ref(&wire.options) }
    }
}

/// The wire type corresponding to [`LauncherSetOptionsRequest`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireLauncherSetOptionsRequest {
    pub options: ::fidl_next::WireU32,
}
static_assertions::const_assert_eq!(std::mem::size_of::<WireLauncherSetOptionsRequest>(), 4);
static_assertions::const_assert_eq!(std::mem::align_of::<WireLauncherSetOptionsRequest>(), 4);

static_assertions::const_assert_eq!(
    std::mem::offset_of!(WireLauncherSetOptionsRequest, options),
    0
);

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

    #[inline]
    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge! {
            let Self {

                options,

            } = &mut *out_;
        }

        ::fidl_next::Wire::zero_padding(options);
    }
}

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,
    ) -> ::core::result::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(PartialEq, Debug)]
pub struct NameInfo {
    pub path: ::std::string::String,

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

impl ::fidl_next::Encodable for NameInfo {
    type Encoded = WireNameInfo<'static>;
}

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(
        self,
        encoder_: &mut ___E,
        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                path,
                directory,

            } = out_;
        }

        ::fidl_next::Encode::encode(self.path, encoder_, path)?;

        ::fidl_next::Encode::encode(self.directory, encoder_, directory)?;

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for NameInfo
where
    ___E: ::fidl_next::Encoder + ?Sized,
    NameInfo: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: ::core::option::Option<Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> ::core::result::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<WireNameInfo<'de>> for NameInfo {
    #[inline]
    fn from_wire(wire: WireNameInfo<'de>) -> Self {
        Self {
            path: ::fidl_next::FromWire::from_wire(wire.path),

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

impl<'de> ::fidl_next::IntoNatural for WireNameInfo<'de> {
    type Natural = NameInfo;
}

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

    pub directory: ::fidl_next::ClientEnd<
        ::fidl_next_fuchsia_io::Directory,
        ::fidl_next::fuchsia::WireChannel,
    >,
}
static_assertions::const_assert_eq!(std::mem::size_of::<WireNameInfo<'_>>(), 24);
static_assertions::const_assert_eq!(std::mem::align_of::<WireNameInfo<'_>>(), 8);

static_assertions::const_assert_eq!(std::mem::offset_of!(WireNameInfo<'_>, path), 0);

static_assertions::const_assert_eq!(std::mem::offset_of!(WireNameInfo<'_>, directory), 16);

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

    #[inline]
    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge! {
            let Self {

                path,
                directory,

            } = &mut *out_;
        }

        ::fidl_next::Wire::zero_padding(path);

        ::fidl_next::Wire::zero_padding(directory);

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

unsafe impl<___D> ::fidl_next::Decode<___D> for WireNameInfo<'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,
    ) -> ::core::result::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(PartialEq, Debug)]
pub struct LauncherAddNamesRequest {
    pub names: ::std::vec::Vec<crate::NameInfo>,
}

impl ::fidl_next::Encodable for LauncherAddNamesRequest {
    type Encoded = WireLauncherAddNamesRequest<'static>;
}

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(
        self,
        encoder_: &mut ___E,
        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                names,

            } = out_;
        }

        ::fidl_next::Encode::encode(self.names, encoder_, names)?;

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for LauncherAddNamesRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    LauncherAddNamesRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: ::core::option::Option<Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> ::core::result::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<WireLauncherAddNamesRequest<'de>> for LauncherAddNamesRequest {
    #[inline]
    fn from_wire(wire: WireLauncherAddNamesRequest<'de>) -> Self {
        Self { names: ::fidl_next::FromWire::from_wire(wire.names) }
    }
}

impl<'de> ::fidl_next::IntoNatural for WireLauncherAddNamesRequest<'de> {
    type Natural = LauncherAddNamesRequest;
}

/// The wire type corresponding to [`LauncherAddNamesRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireLauncherAddNamesRequest<'de> {
    pub names: ::fidl_next::WireVector<'de, crate::WireNameInfo<'de>>,
}
static_assertions::const_assert_eq!(std::mem::size_of::<WireLauncherAddNamesRequest<'_>>(), 16);
static_assertions::const_assert_eq!(std::mem::align_of::<WireLauncherAddNamesRequest<'_>>(), 8);

static_assertions::const_assert_eq!(
    std::mem::offset_of!(WireLauncherAddNamesRequest<'_>, names),
    0
);

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

    #[inline]
    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge! {
            let Self {

                names,

            } = &mut *out_;
        }

        ::fidl_next::Wire::zero_padding(names);
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireLauncherAddNamesRequest<'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,
    ) -> ::core::result::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(PartialEq, Debug)]
pub struct Launcher;

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

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

        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<'static>;

        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<'static>;

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

    pub struct AddArgs;

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

        type Protocol = crate::Launcher;

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

        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<'static>;

        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<'static>;

        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<'static>;

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

    mod ___detail {

        pub struct Launch<T0> {
            info: T0,
        }

        impl<T0> ::fidl_next::Encodable for Launch<T0>
        where
            T0: ::fidl_next::Encodable<Encoded = crate::WireLaunchInfo<'static>>,
        {
            type Encoded = crate::WireLauncherLaunchRequest<'static>;
        }

        unsafe impl<___E, T0> ::fidl_next::Encode<___E> for Launch<T0>
        where
            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
            ___E: ::fidl_next::Encoder,
            ___E: ::fidl_next::fuchsia::HandleEncoder,
            T0: ::fidl_next::Encode<___E, Encoded = crate::WireLaunchInfo<'static>>,
        {
            #[inline]
            fn encode(
                self,
                encoder_: &mut ___E,
                out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
            ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
                ::fidl_next::munge! {
                    let Self::Encoded {
                        info,

                    } = out_;
                }

                ::fidl_next::Encode::encode(self.info, encoder_, info)?;

                Ok(())
            }
        }

        pub struct CreateWithoutStarting<T0> {
            info: T0,
        }

        impl<T0> ::fidl_next::Encodable for CreateWithoutStarting<T0>
        where
            T0: ::fidl_next::Encodable<Encoded = crate::WireLaunchInfo<'static>>,
        {
            type Encoded = crate::WireLauncherCreateWithoutStartingRequest<'static>;
        }

        unsafe impl<___E, T0> ::fidl_next::Encode<___E> for CreateWithoutStarting<T0>
        where
            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
            ___E: ::fidl_next::Encoder,
            ___E: ::fidl_next::fuchsia::HandleEncoder,
            T0: ::fidl_next::Encode<___E, Encoded = crate::WireLaunchInfo<'static>>,
        {
            #[inline]
            fn encode(
                self,
                encoder_: &mut ___E,
                out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
            ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
                ::fidl_next::munge! {
                    let Self::Encoded {
                        info,

                    } = out_;
                }

                ::fidl_next::Encode::encode(self.info, encoder_, info)?;

                Ok(())
            }
        }

        pub struct AddArgs<T0> {
            args: T0,
        }

        impl<T0> ::fidl_next::Encodable for AddArgs<T0>
        where
            T0: ::fidl_next::Encodable<
                    Encoded = ::fidl_next::WireVector<
                        'static,
                        ::fidl_next::WireVector<'static, u8>,
                    >,
                >,
        {
            type Encoded = crate::WireLauncherAddArgsRequest<'static>;
        }

        unsafe impl<___E, T0> ::fidl_next::Encode<___E> for AddArgs<T0>
        where
            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
            ___E: ::fidl_next::Encoder,
            T0: ::fidl_next::Encode<
                    ___E,
                    Encoded = ::fidl_next::WireVector<
                        'static,
                        ::fidl_next::WireVector<'static, u8>,
                    >,
                >,
        {
            #[inline]
            fn encode(
                self,
                encoder_: &mut ___E,
                out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
            ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
                ::fidl_next::munge! {
                    let Self::Encoded {
                        args,

                    } = out_;
                }

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

                Ok(())
            }
        }

        pub struct AddEnvirons<T0> {
            environ: T0,
        }

        impl<T0> ::fidl_next::Encodable for AddEnvirons<T0>
        where
            T0: ::fidl_next::Encodable<
                    Encoded = ::fidl_next::WireVector<
                        'static,
                        ::fidl_next::WireVector<'static, u8>,
                    >,
                >,
        {
            type Encoded = crate::WireLauncherAddEnvironsRequest<'static>;
        }

        unsafe impl<___E, T0> ::fidl_next::Encode<___E> for AddEnvirons<T0>
        where
            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
            ___E: ::fidl_next::Encoder,
            T0: ::fidl_next::Encode<
                    ___E,
                    Encoded = ::fidl_next::WireVector<
                        'static,
                        ::fidl_next::WireVector<'static, u8>,
                    >,
                >,
        {
            #[inline]
            fn encode(
                self,
                encoder_: &mut ___E,
                out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
            ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
                ::fidl_next::munge! {
                    let Self::Encoded {
                        environ,

                    } = out_;
                }

                ::fidl_next::Encode::encode(self.environ, encoder_, environ)?;

                Ok(())
            }
        }

        pub struct AddNames<T0> {
            names: T0,
        }

        impl<T0> ::fidl_next::Encodable for AddNames<T0>
        where
            T0: ::fidl_next::Encodable<
                    Encoded = ::fidl_next::WireVector<'static, crate::WireNameInfo<'static>>,
                >,
        {
            type Encoded = crate::WireLauncherAddNamesRequest<'static>;
        }

        unsafe impl<___E, T0> ::fidl_next::Encode<___E> for AddNames<T0>
        where
            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
            ___E: ::fidl_next::Encoder,
            ___E: ::fidl_next::fuchsia::HandleEncoder,
            T0: ::fidl_next::Encode<
                    ___E,
                    Encoded = ::fidl_next::WireVector<'static, crate::WireNameInfo<'static>>,
                >,
        {
            #[inline]
            fn encode(
                self,
                encoder_: &mut ___E,
                out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
            ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
                ::fidl_next::munge! {
                    let Self::Encoded {
                        names,

                    } = out_;
                }

                ::fidl_next::Encode::encode(self.names, encoder_, names)?;

                Ok(())
            }
        }

        pub struct AddHandles<T0> {
            handles: T0,
        }

        impl<T0> ::fidl_next::Encodable for AddHandles<T0>
        where
            T0: ::fidl_next::Encodable<
                    Encoded = ::fidl_next::WireVector<'static, crate::WireHandleInfo>,
                >,
        {
            type Encoded = crate::WireLauncherAddHandlesRequest<'static>;
        }

        unsafe impl<___E, T0> ::fidl_next::Encode<___E> for AddHandles<T0>
        where
            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
            ___E: ::fidl_next::Encoder,
            ___E: ::fidl_next::fuchsia::HandleEncoder,
            T0: ::fidl_next::Encode<
                    ___E,
                    Encoded = ::fidl_next::WireVector<'static, crate::WireHandleInfo>,
                >,
        {
            #[inline]
            fn encode(
                self,
                encoder_: &mut ___E,
                out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
            ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
                ::fidl_next::munge! {
                    let Self::Encoded {
                        handles,

                    } = out_;
                }

                ::fidl_next::Encode::encode(self.handles, encoder_, handles)?;

                Ok(())
            }
        }

        pub struct SetOptions<T0> {
            options: T0,
        }

        impl<T0> ::fidl_next::Encodable for SetOptions<T0>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU32>,
        {
            type Encoded = crate::WireLauncherSetOptionsRequest;
        }

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

                    } = out_;
                }

                ::fidl_next::Encode::encode(self.options, encoder_, options)?;

                Ok(())
            }
        }

        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::Launcher
        where
            ___T: ::fidl_next::Transport,
        {
            type Client = LauncherClient<___T>;
            type Server = LauncherServer<___T>;
        }

        /// The client for the `Launcher` protocol.
        #[repr(transparent)]
        pub struct LauncherClient<___T: ::fidl_next::Transport> {
            #[allow(dead_code)]
            client: ::fidl_next::protocol::Client<___T>,
        }

        impl<___T> LauncherClient<___T>
        where
            ___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"]
            pub fn launch(
                &self,

                info: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireLaunchInfo<'static>,
                >,
            ) -> ::fidl_next::TwoWayFuture<'_, super::Launch, ___T>
            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.launch_with(Launch { info })
            }

            #[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"]
            pub fn launch_with<___R>(
                &self,
                request: ___R,
            ) -> ::fidl_next::TwoWayFuture<'_, super::Launch, ___T>
            where
                ___R: ::fidl_next::Encode<
                        <___T as ::fidl_next::Transport>::SendBuffer,
                        Encoded = crate::WireLauncherLaunchRequest<'static>,
                    >,
            {
                ::fidl_next::TwoWayFuture::from_untyped(
                    self.client.send_two_way(1239433936316120996, request),
                )
            }

            #[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"]
            pub fn create_without_starting(
                &self,

                info: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireLaunchInfo<'static>,
                >,
            ) -> ::fidl_next::TwoWayFuture<'_, super::CreateWithoutStarting, ___T>
            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.create_without_starting_with(CreateWithoutStarting { info })
            }

            #[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"]
            pub fn create_without_starting_with<___R>(
                &self,
                request: ___R,
            ) -> ::fidl_next::TwoWayFuture<'_, super::CreateWithoutStarting, ___T>
            where
                ___R: ::fidl_next::Encode<
                        <___T as ::fidl_next::Transport>::SendBuffer,
                        Encoded = crate::WireLauncherCreateWithoutStartingRequest<'static>,
                    >,
            {
                ::fidl_next::TwoWayFuture::from_untyped(
                    self.client.send_two_way(8457621991205227361, request),
                )
            }

            #[doc = " Adds the given arguments to the command-line for the process.\n\n Calling this method multiple times concatenates the arguments.\n"]
            pub fn add_args(
                &self,

                args: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireVector<
                        'static,
                        ::fidl_next::WireVector<'static, u8>,
                    >,
                >,
            ) -> ::fidl_next::SendFuture<'_, ___T>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
            {
                self.add_args_with(AddArgs { args })
            }

            #[doc = " Adds the given arguments to the command-line for the process.\n\n Calling this method multiple times concatenates the arguments.\n"]
            pub fn add_args_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
            where
                ___R: ::fidl_next::Encode<
                        <___T as ::fidl_next::Transport>::SendBuffer,
                        Encoded = crate::WireLauncherAddArgsRequest<'static>,
                    >,
            {
                ::fidl_next::SendFuture::from_untyped(
                    self.client.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"]
            pub fn add_environs(
                &self,

                environ: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireVector<
                        'static,
                        ::fidl_next::WireVector<'static, u8>,
                    >,
                >,
            ) -> ::fidl_next::SendFuture<'_, ___T>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
            {
                self.add_environs_with(AddEnvirons { environ })
            }

            #[doc = " Adds the given variables to the environment variables for the process.\n\n Calling this method multiple times concatenates the variables.\n"]
            pub fn add_environs_with<___R>(
                &self,
                request: ___R,
            ) -> ::fidl_next::SendFuture<'_, ___T>
            where
                ___R: ::fidl_next::Encode<
                        <___T as ::fidl_next::Transport>::SendBuffer,
                        Encoded = crate::WireLauncherAddEnvironsRequest<'static>,
                    >,
            {
                ::fidl_next::SendFuture::from_untyped(
                    self.client.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"]
            pub fn add_names(
                &self,

                names: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireVector<'static, crate::WireNameInfo<'static>>,
                >,
            ) -> ::fidl_next::SendFuture<'_, ___T>
            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.add_names_with(AddNames { names })
            }

            #[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"]
            pub fn add_names_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
            where
                ___R: ::fidl_next::Encode<
                        <___T as ::fidl_next::Transport>::SendBuffer,
                        Encoded = crate::WireLauncherAddNamesRequest<'static>,
                    >,
            {
                ::fidl_next::SendFuture::from_untyped(
                    self.client.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"]
            pub fn add_handles(
                &self,

                handles: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireVector<'static, crate::WireHandleInfo>,
                >,
            ) -> ::fidl_next::SendFuture<'_, ___T>
            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.add_handles_with(AddHandles { handles })
            }

            #[doc = " Adds the given handles to the startup handles for the process.\n\n Calling this method multiple times concatenates the handles.\n"]
            pub fn add_handles_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
            where
                ___R: ::fidl_next::Encode<
                        <___T as ::fidl_next::Transport>::SendBuffer,
                        Encoded = crate::WireLauncherAddHandlesRequest<'static>,
                    >,
            {
                ::fidl_next::SendFuture::from_untyped(
                    self.client.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"]
            pub fn set_options(
                &self,

                options: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireU32,
                >,
            ) -> ::fidl_next::SendFuture<'_, ___T>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
            {
                self.set_options_with(SetOptions { options })
            }

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

        /// The server for the `Launcher` protocol.
        #[repr(transparent)]
        pub struct LauncherServer<___T: ::fidl_next::Transport> {
            server: ::fidl_next::protocol::Server<___T>,
        }

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

/// A client handler for the Launcher protocol.
///
/// See [`Launcher`] for more details.
pub trait LauncherClientHandler<
    #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
    #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
>
{
}

impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Launcher
where
    ___H: LauncherClientHandler<___T> + ::core::marker::Send,
    ___T: ::fidl_next::Transport,
    <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>,
{
    async fn on_event(
        handler: &mut ___H,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
        match ordinal {
            ordinal => Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)),
        }
    }
}

/// A server handler for the Launcher protocol.
///
/// See [`Launcher`] for more details.
pub trait LauncherServerHandler<
    #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
    #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
>
{
    #[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,

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

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

    #[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,

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

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

    #[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,

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

    #[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,

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

    #[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,

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

    #[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,

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

    #[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,

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

impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Launcher
where
    ___H: LauncherServerHandler<___T> + ::core::marker::Send,
    ___T: ::fidl_next::Transport,
    <launcher::Launch as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <launcher::CreateWithoutStarting as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <launcher::AddArgs as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <launcher::AddEnvirons as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <launcher::AddNames as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <launcher::AddHandles as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <launcher::SetOptions as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    async fn on_one_way(
        handler: &mut ___H,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) -> ::core::result::Result<
        (),
        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
    > {
        match ordinal {
            4315651119310005522 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => {
                    handler.add_args(decoded).await;
                    Ok(())
                }
                Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
                    ordinal: 4315651119310005522,
                    error,
                }),
            },

            8332725285682026361 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => {
                    handler.add_environs(decoded).await;
                    Ok(())
                }
                Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
                    ordinal: 8332725285682026361,
                    error,
                }),
            },

            2700451326409737826 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => {
                    handler.add_names(decoded).await;
                    Ok(())
                }
                Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
                    ordinal: 2700451326409737826,
                    error,
                }),
            },

            5837318672132580885 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => {
                    handler.add_handles(decoded).await;
                    Ok(())
                }
                Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
                    ordinal: 5837318672132580885,
                    error,
                }),
            },

            6598432479381290375 => match ::fidl_next::DecoderExt::decode(buffer) {
                Ok(decoded) => {
                    handler.set_options(decoded).await;
                    Ok(())
                }
                Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
                    ordinal: 6598432479381290375,
                    error,
                }),
            },

            ordinal => Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)),
        }
    }

    async fn on_two_way(
        handler: &mut ___H,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
        responder: ::fidl_next::protocol::Responder<___T>,
    ) -> ::core::result::Result<
        (),
        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
    > {
        match ordinal {
            1239433936316120996 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => {
                        handler.launch(decoded, responder).await;
                        Ok(())
                    }
                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
                        ordinal: 1239433936316120996,
                        error,
                    }),
                }
            }

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

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => {
                        handler.create_without_starting(decoded, responder).await;
                        Ok(())
                    }
                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
                        ordinal: 8457621991205227361,
                        error,
                    }),
                }
            }

            ordinal => Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)),
        }
    }
}

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

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

    pub root_vmar: ::fidl_next::fuchsia::zx::Vmar,

    pub thread: ::fidl_next::fuchsia::zx::Thread,

    pub entry: u64,

    pub stack: u64,

    pub bootstrap: ::fidl_next::fuchsia::zx::Channel,

    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(
        self,
        encoder_: &mut ___E,
        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> ::core::result::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(self.process, encoder_, process)?;

        ::fidl_next::Encode::encode(self.root_vmar, encoder_, root_vmar)?;

        ::fidl_next::Encode::encode(self.thread, encoder_, thread)?;

        ::fidl_next::Encode::encode(self.entry, encoder_, entry)?;

        ::fidl_next::Encode::encode(self.stack, encoder_, stack)?;

        ::fidl_next::Encode::encode(self.bootstrap, encoder_, bootstrap)?;

        ::fidl_next::Encode::encode(self.vdso_base, encoder_, vdso_base)?;

        ::fidl_next::Encode::encode(self.base, encoder_, base)?;

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for ProcessStartData
where
    ___E: ::fidl_next::Encoder + ?Sized,
    ProcessStartData: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: ::core::option::Option<Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> ::core::result::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<WireProcessStartData> for ProcessStartData {
    #[inline]
    fn from_wire(wire: WireProcessStartData) -> Self {
        Self {
            process: ::fidl_next::FromWire::from_wire(wire.process),

            root_vmar: ::fidl_next::FromWire::from_wire(wire.root_vmar),

            thread: ::fidl_next::FromWire::from_wire(wire.thread),

            entry: ::fidl_next::FromWire::from_wire(wire.entry),

            stack: ::fidl_next::FromWire::from_wire(wire.stack),

            bootstrap: ::fidl_next::FromWire::from_wire(wire.bootstrap),

            vdso_base: ::fidl_next::FromWire::from_wire(wire.vdso_base),

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

impl ::fidl_next::IntoNatural for WireProcessStartData {
    type Natural = ProcessStartData;
}

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

    pub root_vmar: ::fidl_next::fuchsia::WireVmar,

    pub thread: ::fidl_next::fuchsia::WireThread,

    pub entry: ::fidl_next::WireU64,

    pub stack: ::fidl_next::WireU64,

    pub bootstrap: ::fidl_next::fuchsia::WireChannel,

    pub vdso_base: ::fidl_next::WireU64,

    pub base: ::fidl_next::WireU64,
}
static_assertions::const_assert_eq!(std::mem::size_of::<WireProcessStartData>(), 56);
static_assertions::const_assert_eq!(std::mem::align_of::<WireProcessStartData>(), 8);

static_assertions::const_assert_eq!(std::mem::offset_of!(WireProcessStartData, process), 0);

static_assertions::const_assert_eq!(std::mem::offset_of!(WireProcessStartData, root_vmar), 4);

static_assertions::const_assert_eq!(std::mem::offset_of!(WireProcessStartData, thread), 8);

static_assertions::const_assert_eq!(std::mem::offset_of!(WireProcessStartData, entry), 16);

static_assertions::const_assert_eq!(std::mem::offset_of!(WireProcessStartData, stack), 24);

static_assertions::const_assert_eq!(std::mem::offset_of!(WireProcessStartData, bootstrap), 32);

static_assertions::const_assert_eq!(std::mem::offset_of!(WireProcessStartData, vdso_base), 40);

static_assertions::const_assert_eq!(std::mem::offset_of!(WireProcessStartData, base), 48);

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

    #[inline]
    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge! {
            let Self {

                process,
                root_vmar,
                thread,
                entry,
                stack,
                bootstrap,
                vdso_base,
                base,

            } = &mut *out_;
        }

        ::fidl_next::Wire::zero_padding(process);

        ::fidl_next::Wire::zero_padding(root_vmar);

        ::fidl_next::Wire::zero_padding(thread);

        ::fidl_next::Wire::zero_padding(entry);

        ::fidl_next::Wire::zero_padding(stack);

        ::fidl_next::Wire::zero_padding(bootstrap);

        ::fidl_next::Wire::zero_padding(vdso_base);

        ::fidl_next::Wire::zero_padding(base);

        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,
    ) -> ::core::result::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(PartialEq, Clone, Debug)]
pub struct ResolverResolveRequest {
    pub name: ::std::string::String,
}

impl ::fidl_next::Encodable for ResolverResolveRequest {
    type Encoded = WireResolverResolveRequest<'static>;
}

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

            } = out_;
        }

        ::fidl_next::Encode::encode(self.name, encoder_, name)?;

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for ResolverResolveRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder_: &mut ___E,
        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {

                name,

            } = out_;
        }

        ::fidl_next::EncodeRef::encode_ref(&self.name, encoder_, name)?;

        Ok(())
    }
}

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

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

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for ResolverResolveRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    ResolverResolveRequest: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: ::core::option::Option<&Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> ::core::result::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<WireResolverResolveRequest<'de>> for ResolverResolveRequest {
    #[inline]
    fn from_wire(wire: WireResolverResolveRequest<'de>) -> Self {
        Self { name: ::fidl_next::FromWire::from_wire(wire.name) }
    }
}

impl<'de> ::fidl_next::IntoNatural for WireResolverResolveRequest<'de> {
    type Natural = ResolverResolveRequest;
}

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

/// The wire type corresponding to [`ResolverResolveRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireResolverResolveRequest<'de> {
    pub name: ::fidl_next::WireString<'de>,
}
static_assertions::const_assert_eq!(std::mem::size_of::<WireResolverResolveRequest<'_>>(), 16);
static_assertions::const_assert_eq!(std::mem::align_of::<WireResolverResolveRequest<'_>>(), 8);

static_assertions::const_assert_eq!(std::mem::offset_of!(WireResolverResolveRequest<'_>, name), 0);

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

    #[inline]
    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge! {
            let Self {

                name,

            } = &mut *out_;
        }

        ::fidl_next::Wire::zero_padding(name);
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireResolverResolveRequest<'static>
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
    ___D: ::fidl_next::Decoder,
{
    fn decode(
        slot_: ::fidl_next::Slot<'_, Self>,
        decoder_: &mut ___D,
    ) -> ::core::result::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(PartialEq, Debug)]
#[repr(C)]
pub struct ResolverResolveResponse {
    pub status: i32,

    pub executable: ::core::option::Option<::fidl_next::fuchsia::zx::Vmo>,

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

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

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

                && <
                    ::core::option::Option<::fidl_next::fuchsia::zx::Vmo> as ::fidl_next::Encodable
                >::COPY_OPTIMIZATION.is_enabled()

                && <
                    ::core::option::Option<::fidl_next::ClientEnd<::fidl_next_fuchsia_ldsvc::Loader, ::fidl_next::fuchsia::zx::Channel>> 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(
        self,
        encoder_: &mut ___E,
        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                status,
                executable,
                ldsvc,

            } = out_;
        }

        ::fidl_next::Encode::encode(self.status, encoder_, status)?;

        ::fidl_next::Encode::encode(self.executable, encoder_, executable)?;

        ::fidl_next::Encode::encode(self.ldsvc, encoder_, ldsvc)?;

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for ResolverResolveResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    ResolverResolveResponse: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: ::core::option::Option<Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> ::core::result::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<WireResolverResolveResponse> for ResolverResolveResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireResolverResolveResponse, Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true

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

                && <
                    ::core::option::Option<::fidl_next::fuchsia::zx::Vmo> as ::fidl_next::FromWire<::fidl_next::fuchsia::WireOptionalVmo>
                >::COPY_OPTIMIZATION.is_enabled()

                && <
                    ::core::option::Option<::fidl_next::ClientEnd<::fidl_next_fuchsia_ldsvc::Loader, ::fidl_next::fuchsia::zx::Channel>> as ::fidl_next::FromWire<::fidl_next::ClientEnd<::fidl_next_fuchsia_ldsvc::Loader, ::fidl_next::fuchsia::WireOptionalChannel>>
                >::COPY_OPTIMIZATION.is_enabled()

        )
    };

    #[inline]
    fn from_wire(wire: WireResolverResolveResponse) -> Self {
        Self {
            status: ::fidl_next::FromWire::from_wire(wire.status),

            executable: ::fidl_next::FromWire::from_wire(wire.executable),

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

impl ::fidl_next::IntoNatural for WireResolverResolveResponse {
    type Natural = ResolverResolveResponse;
}

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

    pub executable: ::fidl_next::fuchsia::WireOptionalVmo,

    pub ldsvc: ::fidl_next::ClientEnd<
        ::fidl_next_fuchsia_ldsvc::Loader,
        ::fidl_next::fuchsia::WireOptionalChannel,
    >,
}
static_assertions::const_assert_eq!(std::mem::size_of::<WireResolverResolveResponse>(), 12);
static_assertions::const_assert_eq!(std::mem::align_of::<WireResolverResolveResponse>(), 4);

static_assertions::const_assert_eq!(std::mem::offset_of!(WireResolverResolveResponse, status), 0);

static_assertions::const_assert_eq!(
    std::mem::offset_of!(WireResolverResolveResponse, executable),
    4
);

static_assertions::const_assert_eq!(std::mem::offset_of!(WireResolverResolveResponse, ldsvc), 8);

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

    #[inline]
    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge! {
            let Self {

                status,
                executable,
                ldsvc,

            } = &mut *out_;
        }

        ::fidl_next::Wire::zero_padding(status);

        ::fidl_next::Wire::zero_padding(executable);

        ::fidl_next::Wire::zero_padding(ldsvc);
    }
}

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,
    ) -> ::core::result::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(PartialEq, Debug)]
pub struct Resolver;

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

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

        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<'static>;

        type Response = crate::WireResolverResolveResponse;
    }

    mod ___detail {

        pub struct Resolve<T0> {
            name: T0,
        }

        impl<T0> ::fidl_next::Encodable for Resolve<T0>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireString<'static>>,
        {
            type Encoded = crate::WireResolverResolveRequest<'static>;
        }

        unsafe impl<___E, T0> ::fidl_next::Encode<___E> for Resolve<T0>
        where
            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
            ___E: ::fidl_next::Encoder,
            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireString<'static>>,
        {
            #[inline]
            fn encode(
                self,
                encoder_: &mut ___E,
                out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
            ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
                ::fidl_next::munge! {
                    let Self::Encoded {
                        name,

                    } = out_;
                }

                ::fidl_next::Encode::encode(self.name, encoder_, name)?;

                Ok(())
            }
        }

        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::Resolver
        where
            ___T: ::fidl_next::Transport,
        {
            type Client = ResolverClient<___T>;
            type Server = ResolverServer<___T>;
        }

        /// The client for the `Resolver` protocol.
        #[repr(transparent)]
        pub struct ResolverClient<___T: ::fidl_next::Transport> {
            #[allow(dead_code)]
            client: ::fidl_next::protocol::Client<___T>,
        }

        impl<___T> ResolverClient<___T>
        where
            ___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"]
            pub fn resolve(
                &self,

                name: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireString<'static>,
                >,
            ) -> ::fidl_next::TwoWayFuture<'_, super::Resolve, ___T>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
            {
                self.resolve_with(Resolve { name })
            }

            #[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"]
            pub fn resolve_with<___R>(
                &self,
                request: ___R,
            ) -> ::fidl_next::TwoWayFuture<'_, super::Resolve, ___T>
            where
                ___R: ::fidl_next::Encode<
                        <___T as ::fidl_next::Transport>::SendBuffer,
                        Encoded = crate::WireResolverResolveRequest<'static>,
                    >,
            {
                ::fidl_next::TwoWayFuture::from_untyped(
                    self.client.send_two_way(4329530577128037520, request),
                )
            }
        }

        /// The server for the `Resolver` protocol.
        #[repr(transparent)]
        pub struct ResolverServer<___T: ::fidl_next::Transport> {
            server: ::fidl_next::protocol::Server<___T>,
        }

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

/// A client handler for the Resolver protocol.
///
/// See [`Resolver`] for more details.
pub trait ResolverClientHandler<
    #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
    #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
>
{
}

impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Resolver
where
    ___H: ResolverClientHandler<___T> + ::core::marker::Send,
    ___T: ::fidl_next::Transport,
    <resolver::Resolve as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    async fn on_event(
        handler: &mut ___H,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
        match ordinal {
            ordinal => Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)),
        }
    }
}

/// A server handler for the Resolver protocol.
///
/// See [`Resolver`] for more details.
pub trait ResolverServerHandler<
    #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
    #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
>
{
    #[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,

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

        responder: ::fidl_next::Responder<resolver::Resolve, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
}

impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Resolver
where
    ___H: ResolverServerHandler<___T> + ::core::marker::Send,
    ___T: ::fidl_next::Transport,
    <resolver::Resolve as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    async fn on_one_way(
        handler: &mut ___H,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) -> ::core::result::Result<
        (),
        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
    > {
        match ordinal {
            ordinal => Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)),
        }
    }

    async fn on_two_way(
        handler: &mut ___H,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
        responder: ::fidl_next::protocol::Responder<___T>,
    ) -> ::core::result::Result<
        (),
        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
    > {
        match ordinal {
            4329530577128037520 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => {
                        handler.resolve(decoded, responder).await;
                        Ok(())
                    }
                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
                        ordinal: 4329530577128037520,
                        error,
                    }),
                }
            }

            ordinal => Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)),
        }
    }
}

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

    impl ::fidl_next::CompatFrom<crate::HandleInfo> for ::fidl_fuchsia_process::HandleInfo {
        #[inline]
        fn compat_from(value: crate::HandleInfo) -> Self {
            Self {
                handle: ::fidl_next::CompatFrom::compat_from(value.handle),

                id: ::fidl_next::CompatFrom::compat_from(value.id),
            }
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_fuchsia_process::HandleInfo> for crate::HandleInfo {
        #[inline]
        fn compat_from(value: ::fidl_fuchsia_process::HandleInfo) -> Self {
            Self {
                handle: ::fidl_next::CompatFrom::compat_from(value.handle),

                id: ::fidl_next::CompatFrom::compat_from(value.id),
            }
        }
    }

    impl ::fidl_next::CompatFrom<crate::LaunchInfo> for ::fidl_fuchsia_process::LaunchInfo {
        #[inline]
        fn compat_from(value: crate::LaunchInfo) -> Self {
            Self {
                executable: ::fidl_next::CompatFrom::compat_from(value.executable),

                job: ::fidl_next::CompatFrom::compat_from(value.job),

                name: ::fidl_next::CompatFrom::compat_from(value.name),
            }
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_fuchsia_process::LaunchInfo> for crate::LaunchInfo {
        #[inline]
        fn compat_from(value: ::fidl_fuchsia_process::LaunchInfo) -> Self {
            Self {
                executable: ::fidl_next::CompatFrom::compat_from(value.executable),

                job: ::fidl_next::CompatFrom::compat_from(value.job),

                name: ::fidl_next::CompatFrom::compat_from(value.name),
            }
        }
    }

    impl ::fidl_next::CompatFrom<crate::LauncherLaunchRequest>
        for ::fidl_fuchsia_process::LauncherLaunchRequest
    {
        #[inline]
        fn compat_from(value: crate::LauncherLaunchRequest) -> Self {
            Self { info: ::fidl_next::CompatFrom::compat_from(value.info) }
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_fuchsia_process::LauncherLaunchRequest>
        for crate::LauncherLaunchRequest
    {
        #[inline]
        fn compat_from(value: ::fidl_fuchsia_process::LauncherLaunchRequest) -> Self {
            Self { info: ::fidl_next::CompatFrom::compat_from(value.info) }
        }
    }

    impl ::fidl_next::CompatFrom<crate::LauncherLaunchResponse>
        for ::fidl_fuchsia_process::LauncherLaunchResponse
    {
        #[inline]
        fn compat_from(value: crate::LauncherLaunchResponse) -> Self {
            Self {
                status: ::fidl_next::CompatFrom::compat_from(value.status),

                process: ::fidl_next::CompatFrom::compat_from(value.process),
            }
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_fuchsia_process::LauncherLaunchResponse>
        for crate::LauncherLaunchResponse
    {
        #[inline]
        fn compat_from(value: ::fidl_fuchsia_process::LauncherLaunchResponse) -> Self {
            Self {
                status: ::fidl_next::CompatFrom::compat_from(value.status),

                process: ::fidl_next::CompatFrom::compat_from(value.process),
            }
        }
    }

    impl ::fidl_next::CompatFrom<crate::LauncherCreateWithoutStartingRequest>
        for ::fidl_fuchsia_process::LauncherCreateWithoutStartingRequest
    {
        #[inline]
        fn compat_from(value: crate::LauncherCreateWithoutStartingRequest) -> Self {
            Self { info: ::fidl_next::CompatFrom::compat_from(value.info) }
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_fuchsia_process::LauncherCreateWithoutStartingRequest>
        for crate::LauncherCreateWithoutStartingRequest
    {
        #[inline]
        fn compat_from(
            value: ::fidl_fuchsia_process::LauncherCreateWithoutStartingRequest,
        ) -> Self {
            Self { info: ::fidl_next::CompatFrom::compat_from(value.info) }
        }
    }

    impl ::fidl_next::CompatFrom<crate::LauncherCreateWithoutStartingResponse>
        for ::fidl_fuchsia_process::LauncherCreateWithoutStartingResponse
    {
        #[inline]
        fn compat_from(value: crate::LauncherCreateWithoutStartingResponse) -> Self {
            Self {
                status: ::fidl_next::CompatFrom::compat_from(value.status),

                data: ::fidl_next::CompatFrom::compat_from(value.data),
            }
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_fuchsia_process::LauncherCreateWithoutStartingResponse>
        for crate::LauncherCreateWithoutStartingResponse
    {
        #[inline]
        fn compat_from(
            value: ::fidl_fuchsia_process::LauncherCreateWithoutStartingResponse,
        ) -> Self {
            Self {
                status: ::fidl_next::CompatFrom::compat_from(value.status),

                data: ::fidl_next::CompatFrom::compat_from(value.data),
            }
        }
    }

    impl ::fidl_next::CompatFrom<crate::LauncherAddArgsRequest>
        for ::fidl_fuchsia_process::LauncherAddArgsRequest
    {
        #[inline]
        fn compat_from(value: crate::LauncherAddArgsRequest) -> Self {
            Self { args: ::fidl_next::CompatFrom::compat_from(value.args) }
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_fuchsia_process::LauncherAddArgsRequest>
        for crate::LauncherAddArgsRequest
    {
        #[inline]
        fn compat_from(value: ::fidl_fuchsia_process::LauncherAddArgsRequest) -> Self {
            Self { args: ::fidl_next::CompatFrom::compat_from(value.args) }
        }
    }

    impl ::fidl_next::CompatFrom<crate::LauncherAddEnvironsRequest>
        for ::fidl_fuchsia_process::LauncherAddEnvironsRequest
    {
        #[inline]
        fn compat_from(value: crate::LauncherAddEnvironsRequest) -> Self {
            Self { environ: ::fidl_next::CompatFrom::compat_from(value.environ) }
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_fuchsia_process::LauncherAddEnvironsRequest>
        for crate::LauncherAddEnvironsRequest
    {
        #[inline]
        fn compat_from(value: ::fidl_fuchsia_process::LauncherAddEnvironsRequest) -> Self {
            Self { environ: ::fidl_next::CompatFrom::compat_from(value.environ) }
        }
    }

    impl ::fidl_next::CompatFrom<crate::LauncherAddHandlesRequest>
        for ::fidl_fuchsia_process::LauncherAddHandlesRequest
    {
        #[inline]
        fn compat_from(value: crate::LauncherAddHandlesRequest) -> Self {
            Self { handles: ::fidl_next::CompatFrom::compat_from(value.handles) }
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_fuchsia_process::LauncherAddHandlesRequest>
        for crate::LauncherAddHandlesRequest
    {
        #[inline]
        fn compat_from(value: ::fidl_fuchsia_process::LauncherAddHandlesRequest) -> Self {
            Self { handles: ::fidl_next::CompatFrom::compat_from(value.handles) }
        }
    }

    impl ::fidl_next::CompatFrom<crate::LauncherSetOptionsRequest>
        for ::fidl_fuchsia_process::LauncherSetOptionsRequest
    {
        #[inline]
        fn compat_from(value: crate::LauncherSetOptionsRequest) -> Self {
            Self { options: ::fidl_next::CompatFrom::compat_from(value.options) }
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_fuchsia_process::LauncherSetOptionsRequest>
        for crate::LauncherSetOptionsRequest
    {
        #[inline]
        fn compat_from(value: ::fidl_fuchsia_process::LauncherSetOptionsRequest) -> Self {
            Self { options: ::fidl_next::CompatFrom::compat_from(value.options) }
        }
    }

    impl ::fidl_next::CompatFrom<crate::NameInfo> for ::fidl_fuchsia_process::NameInfo {
        #[inline]
        fn compat_from(value: crate::NameInfo) -> Self {
            Self {
                path: ::fidl_next::CompatFrom::compat_from(value.path),

                directory: ::fidl_next::CompatFrom::compat_from(value.directory),
            }
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_fuchsia_process::NameInfo> for crate::NameInfo {
        #[inline]
        fn compat_from(value: ::fidl_fuchsia_process::NameInfo) -> Self {
            Self {
                path: ::fidl_next::CompatFrom::compat_from(value.path),

                directory: ::fidl_next::CompatFrom::compat_from(value.directory),
            }
        }
    }

    impl ::fidl_next::CompatFrom<crate::LauncherAddNamesRequest>
        for ::fidl_fuchsia_process::LauncherAddNamesRequest
    {
        #[inline]
        fn compat_from(value: crate::LauncherAddNamesRequest) -> Self {
            Self { names: ::fidl_next::CompatFrom::compat_from(value.names) }
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_fuchsia_process::LauncherAddNamesRequest>
        for crate::LauncherAddNamesRequest
    {
        #[inline]
        fn compat_from(value: ::fidl_fuchsia_process::LauncherAddNamesRequest) -> Self {
            Self { names: ::fidl_next::CompatFrom::compat_from(value.names) }
        }
    }

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

    impl ::fidl_next::CompatFrom<crate::Launcher> for ::fidl_fuchsia_process::LauncherMarker {
        fn compat_from(_: crate::Launcher) -> Self {
            Self
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_fuchsia_process::LauncherMarker> for crate::Launcher {
        fn compat_from(_: ::fidl_fuchsia_process::LauncherMarker) -> Self {
            Self
        }
    }

    #[cfg(target_os = "fuchsia")]

    impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_process::LauncherProxy> for crate::Launcher {
        fn client_compat_from(
            proxy: ::fidl_fuchsia_process::LauncherProxy,
        ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
            let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
            let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
            ::fidl_next::ClientDispatcher::new(client_end)
        }
    }

    impl ::fidl_next::CompatFrom<crate::ProcessStartData> for ::fidl_fuchsia_process::ProcessStartData {
        #[inline]
        fn compat_from(value: crate::ProcessStartData) -> Self {
            Self {
                process: ::fidl_next::CompatFrom::compat_from(value.process),

                root_vmar: ::fidl_next::CompatFrom::compat_from(value.root_vmar),

                thread: ::fidl_next::CompatFrom::compat_from(value.thread),

                entry: ::fidl_next::CompatFrom::compat_from(value.entry),

                stack: ::fidl_next::CompatFrom::compat_from(value.stack),

                bootstrap: ::fidl_next::CompatFrom::compat_from(value.bootstrap),

                vdso_base: ::fidl_next::CompatFrom::compat_from(value.vdso_base),

                base: ::fidl_next::CompatFrom::compat_from(value.base),
            }
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_fuchsia_process::ProcessStartData> for crate::ProcessStartData {
        #[inline]
        fn compat_from(value: ::fidl_fuchsia_process::ProcessStartData) -> Self {
            Self {
                process: ::fidl_next::CompatFrom::compat_from(value.process),

                root_vmar: ::fidl_next::CompatFrom::compat_from(value.root_vmar),

                thread: ::fidl_next::CompatFrom::compat_from(value.thread),

                entry: ::fidl_next::CompatFrom::compat_from(value.entry),

                stack: ::fidl_next::CompatFrom::compat_from(value.stack),

                bootstrap: ::fidl_next::CompatFrom::compat_from(value.bootstrap),

                vdso_base: ::fidl_next::CompatFrom::compat_from(value.vdso_base),

                base: ::fidl_next::CompatFrom::compat_from(value.base),
            }
        }
    }

    impl ::fidl_next::CompatFrom<crate::ResolverResolveRequest>
        for ::fidl_fuchsia_process::ResolverResolveRequest
    {
        #[inline]
        fn compat_from(value: crate::ResolverResolveRequest) -> Self {
            Self { name: ::fidl_next::CompatFrom::compat_from(value.name) }
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_fuchsia_process::ResolverResolveRequest>
        for crate::ResolverResolveRequest
    {
        #[inline]
        fn compat_from(value: ::fidl_fuchsia_process::ResolverResolveRequest) -> Self {
            Self { name: ::fidl_next::CompatFrom::compat_from(value.name) }
        }
    }

    impl ::fidl_next::CompatFrom<crate::ResolverResolveResponse>
        for ::fidl_fuchsia_process::ResolverResolveResponse
    {
        #[inline]
        fn compat_from(value: crate::ResolverResolveResponse) -> Self {
            Self {
                status: ::fidl_next::CompatFrom::compat_from(value.status),

                executable: ::fidl_next::CompatFrom::compat_from(value.executable),

                ldsvc: ::fidl_next::CompatFrom::compat_from(value.ldsvc),
            }
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_fuchsia_process::ResolverResolveResponse>
        for crate::ResolverResolveResponse
    {
        #[inline]
        fn compat_from(value: ::fidl_fuchsia_process::ResolverResolveResponse) -> Self {
            Self {
                status: ::fidl_next::CompatFrom::compat_from(value.status),

                executable: ::fidl_next::CompatFrom::compat_from(value.executable),

                ldsvc: ::fidl_next::CompatFrom::compat_from(value.ldsvc),
            }
        }
    }

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

    impl ::fidl_next::CompatFrom<crate::Resolver> for ::fidl_fuchsia_process::ResolverMarker {
        fn compat_from(_: crate::Resolver) -> Self {
            Self
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_fuchsia_process::ResolverMarker> for crate::Resolver {
        fn compat_from(_: ::fidl_fuchsia_process::ResolverMarker) -> Self {
            Self
        }
    }

    #[cfg(target_os = "fuchsia")]

    impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_process::ResolverProxy> for crate::Resolver {
        fn client_compat_from(
            proxy: ::fidl_fuchsia_process::ResolverProxy,
        ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
            let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
            let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
            ::fidl_next::ClientDispatcher::new(client_end)
        }
    }
}