fdomain_fuchsia_process/

fdomain_fuchsia_process.rs

// WARNING: This file is machine generated by fidlgen.

#![warn(clippy::all)]
#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]

use bitflags::bitflags;
use fdomain_client::fidl::{ControlHandle as _, FDomainFlexibleIntoResult as _, Responder as _};
use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
pub use fidl_fuchsia_process__common::*;
use futures::future::{self, MaybeDone, TryFutureExt};
use zx_status;

/// Information about a handle provided to a process at startup.
///
/// Processes are given a set of initial handles as part of the bootstrapping
/// sequence. Some of these handles are associated with process argument
/// identifiers that designate their intended use by the new process.
///
/// This structure represents one such handle and its associated identifier.
#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct HandleInfo {
    /// The handle to use for this process argument.
    pub handle: fdomain_client::Handle,
    /// Process argument identifier.
    ///
    /// See <zircon/processargs.h> for definitions of well-known process
    /// arguments.
    pub id: u32,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect> for HandleInfo {}

/// The information needed to launch a process.
#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct LaunchInfo {
    /// The executable to run in the process.
    pub executable: fdomain_client::Vmo,
    /// The job in which to create the process.
    pub job: fdomain_client::Job,
    /// The name to assign to the created process.
    pub name: String,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect> for LaunchInfo {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct LauncherAddHandlesRequest {
    pub handles: Vec<HandleInfo>,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect> for LauncherAddHandlesRequest {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct LauncherAddNamesRequest {
    pub names: Vec<NameInfo>,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect> for LauncherAddNamesRequest {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct LauncherCreateWithoutStartingRequest {
    pub info: LaunchInfo,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect>
    for LauncherCreateWithoutStartingRequest
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct LauncherCreateWithoutStartingResponse {
    pub status: i32,
    pub data: Option<Box<ProcessStartData>>,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect>
    for LauncherCreateWithoutStartingResponse
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct LauncherLaunchRequest {
    pub info: LaunchInfo,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect> for LauncherLaunchRequest {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct LauncherLaunchResponse {
    pub status: i32,
    pub process: Option<fdomain_client::Process>,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect> for LauncherLaunchResponse {}

/// A namespace entry provided to a process at startup.
///
/// Processes are given a set of initial handles as part of the bootstrapping
/// sequence. Some of these handles are associated with paths that designate
/// their intended use by the new process as namespace entries.
///
/// This structure represents one such handle and its associated namespace path.
#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct NameInfo {
    /// Path at which to install the associated directory.
    ///
    /// Must be an absolute path (i.e., start with '/').
    pub path: String,
    /// The associated directory.
    pub directory: fdomain_client::fidl::ClientEnd<fdomain_fuchsia_io::DirectoryMarker>,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect> for NameInfo {}

/// The information required to start a process.
///
/// To start the process, call `zx_process_start` with the arguments provided.
#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ProcessStartData {
    /// The process that was created.
    pub process: fdomain_client::Process,
    /// The vmar object that was created when the process was created.
    ///
    /// See <https://fuchsia.dev/fuchsia-src/reference/syscalls/process_create.md>.
    pub root_vmar: fdomain_client::Vmar,
    /// The initial thread for the process.
    ///
    /// Should be passed to `zx_process_start` when starting the process.
    pub thread: fdomain_client::Thread,
    /// The address of the initial entry point in the process.
    ///
    /// Should be passed to `zx_process_start` when starting the process.
    pub entry: u64,
    /// The stack pointer value for the initial thread of the process.
    ///
    /// Should be passed to `zx_process_start` when starting the process.
    pub stack: u64,
    /// The bootstrap channel to pass to the process on startup.
    ///
    /// Should be passed to `zx_process_start` when starting the process.
    pub bootstrap: fdomain_client::Channel,
    /// The base address of the vDSO to pass to the process on startup.
    ///
    /// Should be passed to `zx_process_start` when starting the process.
    pub vdso_base: u64,
    /// The base load address of the ELF file loaded.
    ///
    /// Most often used by debuggers or other tools that inspect the process.
    pub base: u64,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect> for ProcessStartData {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ResolverResolveResponse {
    pub status: i32,
    pub executable: Option<fdomain_client::Vmo>,
    pub ldsvc: Option<fdomain_client::fidl::ClientEnd<fdomain_fuchsia_ldsvc::LoaderMarker>>,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect> for ResolverResolveResponse {}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct LauncherMarker;

impl fdomain_client::fidl::ProtocolMarker for LauncherMarker {
    type Proxy = LauncherProxy;
    type RequestStream = LauncherRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.process.Launcher";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for LauncherMarker {}

pub trait LauncherProxyInterface: Send + Sync {
    type LaunchResponseFut: std::future::Future<Output = Result<(i32, Option<fdomain_client::Process>), fidl::Error>>
        + Send;
    fn r#launch(&self, info: LaunchInfo) -> Self::LaunchResponseFut;
    type CreateWithoutStartingResponseFut: std::future::Future<Output = Result<(i32, Option<Box<ProcessStartData>>), fidl::Error>>
        + Send;
    fn r#create_without_starting(&self, info: LaunchInfo)
    -> Self::CreateWithoutStartingResponseFut;
    fn r#add_args(&self, args: &[Vec<u8>]) -> Result<(), fidl::Error>;
    fn r#add_environs(&self, environ: &[Vec<u8>]) -> Result<(), fidl::Error>;
    fn r#add_names(&self, names: Vec<NameInfo>) -> Result<(), fidl::Error>;
    fn r#add_handles(&self, handles: Vec<HandleInfo>) -> Result<(), fidl::Error>;
    fn r#set_options(&self, options: u32) -> Result<(), fidl::Error>;
}

#[derive(Debug, Clone)]
pub struct LauncherProxy {
    client: fidl::client::Client<fdomain_client::fidl::FDomainResourceDialect>,
}

impl fdomain_client::fidl::Proxy for LauncherProxy {
    type Protocol = LauncherMarker;

    fn from_channel(inner: fdomain_client::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<fdomain_client::Channel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &fdomain_client::Channel {
        self.client.as_channel()
    }
}

impl LauncherProxy {
    /// Create a new Proxy for fuchsia.process/Launcher.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name = <LauncherMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> LauncherEventStream {
        LauncherEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Creates and starts the process described by `info`.
    ///
    /// After processing this message, the `Launcher` is reset to its initial
    /// state and is ready to launch another process.
    ///
    /// `process` is present if, and only if, `status` is `ZX_OK`.
    pub fn r#launch(
        &self,
        mut info: LaunchInfo,
    ) -> fidl::client::QueryResponseFut<
        (i32, Option<fdomain_client::Process>),
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        LauncherProxyInterface::r#launch(self, info)
    }

    /// Creates the process described by `info` but does not start it.
    ///
    /// After processing this message, the `Launcher` is reset to its initial
    /// state and is ready to launch another process.
    ///
    /// The caller is responsible for calling `zx_process_start` using the data
    /// in `ProcessStartData` to actually start the process.
    ///
    /// `data` is present if, and only if, `status` is `ZX_OK`.
    pub fn r#create_without_starting(
        &self,
        mut info: LaunchInfo,
    ) -> fidl::client::QueryResponseFut<
        (i32, Option<Box<ProcessStartData>>),
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        LauncherProxyInterface::r#create_without_starting(self, info)
    }

    /// Adds the given arguments to the command-line for the process.
    ///
    /// Calling this method multiple times concatenates the arguments.
    pub fn r#add_args(&self, mut args: &[Vec<u8>]) -> Result<(), fidl::Error> {
        LauncherProxyInterface::r#add_args(self, args)
    }

    /// Adds the given variables to the environment variables for the process.
    ///
    /// Calling this method multiple times concatenates the variables.
    pub fn r#add_environs(&self, mut environ: &[Vec<u8>]) -> Result<(), fidl::Error> {
        LauncherProxyInterface::r#add_environs(self, environ)
    }

    /// Adds the given names to the namespace for the process.
    ///
    /// The paths in the namespace must be non-overlapping. See
    /// <https://fuchsia.dev/fuchsia-src/concepts/process/namespaces> for details.
    ///
    /// Calling this method multiple times concatenates the names.
    pub fn r#add_names(&self, mut names: Vec<NameInfo>) -> Result<(), fidl::Error> {
        LauncherProxyInterface::r#add_names(self, names)
    }

    /// Adds the given handles to the startup handles for the process.
    ///
    /// Calling this method multiple times concatenates the handles.
    pub fn r#add_handles(&self, mut handles: Vec<HandleInfo>) -> Result<(), fidl::Error> {
        LauncherProxyInterface::r#add_handles(self, handles)
    }

    /// Sets the options with which the process is created.
    ///
    /// Calling this method multiple times will overwrite the current options.
    pub fn r#set_options(&self, mut options: u32) -> Result<(), fidl::Error> {
        LauncherProxyInterface::r#set_options(self, options)
    }
}

impl LauncherProxyInterface for LauncherProxy {
    type LaunchResponseFut = fidl::client::QueryResponseFut<
        (i32, Option<fdomain_client::Process>),
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#launch(&self, mut info: LaunchInfo) -> Self::LaunchResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, Option<fdomain_client::Process>), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                LauncherLaunchResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x11335a9928afbfa4,
            >(_buf?)?;
            Ok((_response.status, _response.process))
        }
        self.client
            .send_query_and_decode::<LauncherLaunchRequest, (i32, Option<fdomain_client::Process>)>(
                (&mut info,),
                0x11335a9928afbfa4,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type CreateWithoutStartingResponseFut = fidl::client::QueryResponseFut<
        (i32, Option<Box<ProcessStartData>>),
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#create_without_starting(
        &self,
        mut info: LaunchInfo,
    ) -> Self::CreateWithoutStartingResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, Option<Box<ProcessStartData>>), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                LauncherCreateWithoutStartingResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x755f8263fe51cb61,
            >(_buf?)?;
            Ok((_response.status, _response.data))
        }
        self.client.send_query_and_decode::<
            LauncherCreateWithoutStartingRequest,
            (i32, Option<Box<ProcessStartData>>),
        >(
            (&mut info,),
            0x755f8263fe51cb61,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#add_args(&self, mut args: &[Vec<u8>]) -> Result<(), fidl::Error> {
        self.client.send::<LauncherAddArgsRequest>(
            (args,),
            0x3be445d3e4fd6512,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#add_environs(&self, mut environ: &[Vec<u8>]) -> Result<(), fidl::Error> {
        self.client.send::<LauncherAddEnvironsRequest>(
            (environ,),
            0x73a3c97fa7fe1779,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#add_names(&self, mut names: Vec<NameInfo>) -> Result<(), fidl::Error> {
        self.client.send::<LauncherAddNamesRequest>(
            (names.as_mut(),),
            0x2579ee2c7be28662,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#add_handles(&self, mut handles: Vec<HandleInfo>) -> Result<(), fidl::Error> {
        self.client.send::<LauncherAddHandlesRequest>(
            (handles.as_mut(),),
            0x51025267a537a615,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_options(&self, mut options: u32) -> Result<(), fidl::Error> {
        self.client.send::<LauncherSetOptionsRequest>(
            (options,),
            0x5b92576147ebfd87,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

pub struct LauncherEventStream {
    event_receiver: fidl::client::EventReceiver<fdomain_client::fidl::FDomainResourceDialect>,
}

impl std::marker::Unpin for LauncherEventStream {}

impl futures::stream::FusedStream for LauncherEventStream {
    fn is_terminated(&self) -> bool {
        self.event_receiver.is_terminated()
    }
}

impl futures::Stream for LauncherEventStream {
    type Item = Result<LauncherEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(LauncherEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum LauncherEvent {}

impl LauncherEvent {
    /// Decodes a message buffer as a [`LauncherEvent`].
    fn decode(
        mut buf: <fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<LauncherEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <LauncherMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.process/Launcher.
pub struct LauncherRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
    is_terminated: bool,
}

impl std::marker::Unpin for LauncherRequestStream {}

impl futures::stream::FusedStream for LauncherRequestStream {
    fn is_terminated(&self) -> bool {
        self.is_terminated
    }
}

impl fdomain_client::fidl::RequestStream for LauncherRequestStream {
    type Protocol = LauncherMarker;
    type ControlHandle = LauncherControlHandle;

    fn from_channel(channel: fdomain_client::Channel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        LauncherControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for LauncherRequestStream {
    type Item = Result<LauncherRequest, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled LauncherRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(e))) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x11335a9928afbfa4 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            LauncherLaunchRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<LauncherLaunchRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = LauncherControlHandle { inner: this.inner.clone() };
                        Ok(LauncherRequest::Launch {
                            info: req.info,

                            responder: LauncherLaunchResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x755f8263fe51cb61 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            LauncherCreateWithoutStartingRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<LauncherCreateWithoutStartingRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = LauncherControlHandle { inner: this.inner.clone() };
                        Ok(LauncherRequest::CreateWithoutStarting {
                            info: req.info,

                            responder: LauncherCreateWithoutStartingResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3be445d3e4fd6512 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            LauncherAddArgsRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<LauncherAddArgsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = LauncherControlHandle { inner: this.inner.clone() };
                        Ok(LauncherRequest::AddArgs { args: req.args, control_handle })
                    }
                    0x73a3c97fa7fe1779 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            LauncherAddEnvironsRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<LauncherAddEnvironsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = LauncherControlHandle { inner: this.inner.clone() };
                        Ok(LauncherRequest::AddEnvirons { environ: req.environ, control_handle })
                    }
                    0x2579ee2c7be28662 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            LauncherAddNamesRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<LauncherAddNamesRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = LauncherControlHandle { inner: this.inner.clone() };
                        Ok(LauncherRequest::AddNames { names: req.names, control_handle })
                    }
                    0x51025267a537a615 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            LauncherAddHandlesRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<LauncherAddHandlesRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = LauncherControlHandle { inner: this.inner.clone() };
                        Ok(LauncherRequest::AddHandles { handles: req.handles, control_handle })
                    }
                    0x5b92576147ebfd87 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            LauncherSetOptionsRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<LauncherSetOptionsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = LauncherControlHandle { inner: this.inner.clone() };
                        Ok(LauncherRequest::SetOptions { options: req.options, control_handle })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <LauncherMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// A low-level interface for launching processes.
///
/// This interface is used for manually assembling a process. The caller supplies
/// all the capabilities for the newly created process.
///
/// That create processes typically use `fdio_spawn` or `fdio_spawn_etc` rather
/// than using this interface directly. The `fdio_spawn` and `fdio_spawn_etc`
/// functions are implemented using this interface.
///
/// Debuggers and other clients that need to create processes in a suspended
/// state often use this interface directly. These clients use the
/// `CreateWithoutStarting` method to create the process without actually
/// starting it.
#[derive(Debug)]
pub enum LauncherRequest {
    /// Creates and starts the process described by `info`.
    ///
    /// After processing this message, the `Launcher` is reset to its initial
    /// state and is ready to launch another process.
    ///
    /// `process` is present if, and only if, `status` is `ZX_OK`.
    Launch { info: LaunchInfo, responder: LauncherLaunchResponder },
    /// Creates the process described by `info` but does not start it.
    ///
    /// After processing this message, the `Launcher` is reset to its initial
    /// state and is ready to launch another process.
    ///
    /// The caller is responsible for calling `zx_process_start` using the data
    /// in `ProcessStartData` to actually start the process.
    ///
    /// `data` is present if, and only if, `status` is `ZX_OK`.
    CreateWithoutStarting { info: LaunchInfo, responder: LauncherCreateWithoutStartingResponder },
    /// Adds the given arguments to the command-line for the process.
    ///
    /// Calling this method multiple times concatenates the arguments.
    AddArgs { args: Vec<Vec<u8>>, control_handle: LauncherControlHandle },
    /// Adds the given variables to the environment variables for the process.
    ///
    /// Calling this method multiple times concatenates the variables.
    AddEnvirons { environ: Vec<Vec<u8>>, control_handle: LauncherControlHandle },
    /// Adds the given names to the namespace for the process.
    ///
    /// The paths in the namespace must be non-overlapping. See
    /// <https://fuchsia.dev/fuchsia-src/concepts/process/namespaces> for details.
    ///
    /// Calling this method multiple times concatenates the names.
    AddNames { names: Vec<NameInfo>, control_handle: LauncherControlHandle },
    /// Adds the given handles to the startup handles for the process.
    ///
    /// Calling this method multiple times concatenates the handles.
    AddHandles { handles: Vec<HandleInfo>, control_handle: LauncherControlHandle },
    /// Sets the options with which the process is created.
    ///
    /// Calling this method multiple times will overwrite the current options.
    SetOptions { options: u32, control_handle: LauncherControlHandle },
}

impl LauncherRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_launch(self) -> Option<(LaunchInfo, LauncherLaunchResponder)> {
        if let LauncherRequest::Launch { info, responder } = self {
            Some((info, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_create_without_starting(
        self,
    ) -> Option<(LaunchInfo, LauncherCreateWithoutStartingResponder)> {
        if let LauncherRequest::CreateWithoutStarting { info, responder } = self {
            Some((info, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_args(self) -> Option<(Vec<Vec<u8>>, LauncherControlHandle)> {
        if let LauncherRequest::AddArgs { args, control_handle } = self {
            Some((args, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_environs(self) -> Option<(Vec<Vec<u8>>, LauncherControlHandle)> {
        if let LauncherRequest::AddEnvirons { environ, control_handle } = self {
            Some((environ, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_names(self) -> Option<(Vec<NameInfo>, LauncherControlHandle)> {
        if let LauncherRequest::AddNames { names, control_handle } = self {
            Some((names, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_handles(self) -> Option<(Vec<HandleInfo>, LauncherControlHandle)> {
        if let LauncherRequest::AddHandles { handles, control_handle } = self {
            Some((handles, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_options(self) -> Option<(u32, LauncherControlHandle)> {
        if let LauncherRequest::SetOptions { options, control_handle } = self {
            Some((options, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            LauncherRequest::Launch { .. } => "launch",
            LauncherRequest::CreateWithoutStarting { .. } => "create_without_starting",
            LauncherRequest::AddArgs { .. } => "add_args",
            LauncherRequest::AddEnvirons { .. } => "add_environs",
            LauncherRequest::AddNames { .. } => "add_names",
            LauncherRequest::AddHandles { .. } => "add_handles",
            LauncherRequest::SetOptions { .. } => "set_options",
        }
    }
}

#[derive(Debug, Clone)]
pub struct LauncherControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
}

impl fdomain_client::fidl::ControlHandle for LauncherControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fdomain_client::OnFDomainSignals {
        self.inner.channel().on_closed()
    }
}

impl LauncherControlHandle {}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct LauncherLaunchResponder {
    control_handle: std::mem::ManuallyDrop<LauncherControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`LauncherControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for LauncherLaunchResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for LauncherLaunchResponder {
    type ControlHandle = LauncherControlHandle;

    fn control_handle(&self) -> &LauncherControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl LauncherLaunchResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut status: i32,
        mut process: Option<fdomain_client::Process>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(status, process);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut status: i32,
        mut process: Option<fdomain_client::Process>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(status, process);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut status: i32,
        mut process: Option<fdomain_client::Process>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<LauncherLaunchResponse>(
            (status, process),
            self.tx_id,
            0x11335a9928afbfa4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct LauncherCreateWithoutStartingResponder {
    control_handle: std::mem::ManuallyDrop<LauncherControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`LauncherControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for LauncherCreateWithoutStartingResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for LauncherCreateWithoutStartingResponder {
    type ControlHandle = LauncherControlHandle;

    fn control_handle(&self) -> &LauncherControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl LauncherCreateWithoutStartingResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut status: i32,
        mut data: Option<ProcessStartData>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(status, data);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut status: i32,
        mut data: Option<ProcessStartData>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(status, data);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut status: i32,
        mut data: Option<ProcessStartData>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<LauncherCreateWithoutStartingResponse>(
            (status, data.as_mut()),
            self.tx_id,
            0x755f8263fe51cb61,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct ResolverMarker;

impl fdomain_client::fidl::ProtocolMarker for ResolverMarker {
    type Proxy = ResolverProxy;
    type RequestStream = ResolverRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.process.Resolver";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for ResolverMarker {}

pub trait ResolverProxyInterface: Send + Sync {
    type ResolveResponseFut: std::future::Future<
            Output = Result<
                (
                    i32,
                    Option<fdomain_client::Vmo>,
                    Option<fdomain_client::fidl::ClientEnd<fdomain_fuchsia_ldsvc::LoaderMarker>>,
                ),
                fidl::Error,
            >,
        > + Send;
    fn r#resolve(&self, name: &str) -> Self::ResolveResponseFut;
}

#[derive(Debug, Clone)]
pub struct ResolverProxy {
    client: fidl::client::Client<fdomain_client::fidl::FDomainResourceDialect>,
}

impl fdomain_client::fidl::Proxy for ResolverProxy {
    type Protocol = ResolverMarker;

    fn from_channel(inner: fdomain_client::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<fdomain_client::Channel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &fdomain_client::Channel {
        self.client.as_channel()
    }
}

impl ResolverProxy {
    /// Create a new Proxy for fuchsia.process/Resolver.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name = <ResolverMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> ResolverEventStream {
        ResolverEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Resolves the given `name` to an `executable` and an shared library
    /// loader.
    ///
    /// If present, the `executable` is suitable for use as the `executable`
    /// property of `LaunchInfo` -- in particular, it will have `ZX_RIGHT_EXECUTE`.
    /// If present, the `ldsvc` is suitable for use as the `PA_LDSVC_LOADER`
    /// handle when launching the process.
    ///
    /// For example, the resolver might locate the given `name` inside a package
    /// and return the executable binary from the package as well as a shared
    /// library loader scoped to that package.
    pub fn r#resolve(
        &self,
        mut name: &str,
    ) -> fidl::client::QueryResponseFut<
        (
            i32,
            Option<fdomain_client::Vmo>,
            Option<fdomain_client::fidl::ClientEnd<fdomain_fuchsia_ldsvc::LoaderMarker>>,
        ),
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        ResolverProxyInterface::r#resolve(self, name)
    }
}

impl ResolverProxyInterface for ResolverProxy {
    type ResolveResponseFut = fidl::client::QueryResponseFut<
        (
            i32,
            Option<fdomain_client::Vmo>,
            Option<fdomain_client::fidl::ClientEnd<fdomain_fuchsia_ldsvc::LoaderMarker>>,
        ),
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#resolve(&self, mut name: &str) -> Self::ResolveResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<
            (
                i32,
                Option<fdomain_client::Vmo>,
                Option<fdomain_client::fidl::ClientEnd<fdomain_fuchsia_ldsvc::LoaderMarker>>,
            ),
            fidl::Error,
        > {
            let _response = fidl::client::decode_transaction_body::<
                ResolverResolveResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x3c15951efde89c90,
            >(_buf?)?;
            Ok((_response.status, _response.executable, _response.ldsvc))
        }
        self.client.send_query_and_decode::<ResolverResolveRequest, (
            i32,
            Option<fdomain_client::Vmo>,
            Option<fdomain_client::fidl::ClientEnd<fdomain_fuchsia_ldsvc::LoaderMarker>>,
        )>(
            (name,), 0x3c15951efde89c90, fidl::encoding::DynamicFlags::empty(), _decode
        )
    }
}

pub struct ResolverEventStream {
    event_receiver: fidl::client::EventReceiver<fdomain_client::fidl::FDomainResourceDialect>,
}

impl std::marker::Unpin for ResolverEventStream {}

impl futures::stream::FusedStream for ResolverEventStream {
    fn is_terminated(&self) -> bool {
        self.event_receiver.is_terminated()
    }
}

impl futures::Stream for ResolverEventStream {
    type Item = Result<ResolverEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(ResolverEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum ResolverEvent {}

impl ResolverEvent {
    /// Decodes a message buffer as a [`ResolverEvent`].
    fn decode(
        mut buf: <fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<ResolverEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <ResolverMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.process/Resolver.
pub struct ResolverRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
    is_terminated: bool,
}

impl std::marker::Unpin for ResolverRequestStream {}

impl futures::stream::FusedStream for ResolverRequestStream {
    fn is_terminated(&self) -> bool {
        self.is_terminated
    }
}

impl fdomain_client::fidl::RequestStream for ResolverRequestStream {
    type Protocol = ResolverMarker;
    type ControlHandle = ResolverControlHandle;

    fn from_channel(channel: fdomain_client::Channel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        ResolverControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for ResolverRequestStream {
    type Item = Result<ResolverRequest, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled ResolverRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(e))) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x3c15951efde89c90 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ResolverResolveRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<ResolverResolveRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ResolverControlHandle { inner: this.inner.clone() };
                        Ok(ResolverRequest::Resolve {
                            name: req.name,

                            responder: ResolverResolveResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <ResolverMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// An interface for resolving names to executables and library loaders.
///
/// An executable itself is often not sufficient to create a working process
/// because many executables also load shared libraries. On Fuchsia, there is no
/// global pool of shared libraries. Instead, every process has an associated
/// `fuchsia.ldsvc.Loader`, which provides access to a private pool of shared
/// libraries appropriate for that process.
///
/// This interface provides a protocol for resolving a name into both the
/// `zx.Handle:VMO` for the executable and the `fuchsia.ldsvc.Loader` for its
/// associated shared libraries.
///
/// This interface is rarely used directly. Instead, `fdio_spawn` and
/// `fdio_spawn_etc` use this interface internally when they try to run a file
/// with a `#!resolve` directive.
#[derive(Debug)]
pub enum ResolverRequest {
    /// Resolves the given `name` to an `executable` and an shared library
    /// loader.
    ///
    /// If present, the `executable` is suitable for use as the `executable`
    /// property of `LaunchInfo` -- in particular, it will have `ZX_RIGHT_EXECUTE`.
    /// If present, the `ldsvc` is suitable for use as the `PA_LDSVC_LOADER`
    /// handle when launching the process.
    ///
    /// For example, the resolver might locate the given `name` inside a package
    /// and return the executable binary from the package as well as a shared
    /// library loader scoped to that package.
    Resolve { name: String, responder: ResolverResolveResponder },
}

impl ResolverRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_resolve(self) -> Option<(String, ResolverResolveResponder)> {
        if let ResolverRequest::Resolve { name, responder } = self {
            Some((name, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            ResolverRequest::Resolve { .. } => "resolve",
        }
    }
}

#[derive(Debug, Clone)]
pub struct ResolverControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
}

impl fdomain_client::fidl::ControlHandle for ResolverControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fdomain_client::OnFDomainSignals {
        self.inner.channel().on_closed()
    }
}

impl ResolverControlHandle {}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct ResolverResolveResponder {
    control_handle: std::mem::ManuallyDrop<ResolverControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`ResolverControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for ResolverResolveResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for ResolverResolveResponder {
    type ControlHandle = ResolverControlHandle;

    fn control_handle(&self) -> &ResolverControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl ResolverResolveResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut status: i32,
        mut executable: Option<fdomain_client::Vmo>,
        mut ldsvc: Option<fdomain_client::fidl::ClientEnd<fdomain_fuchsia_ldsvc::LoaderMarker>>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(status, executable, ldsvc);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut status: i32,
        mut executable: Option<fdomain_client::Vmo>,
        mut ldsvc: Option<fdomain_client::fidl::ClientEnd<fdomain_fuchsia_ldsvc::LoaderMarker>>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(status, executable, ldsvc);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut status: i32,
        mut executable: Option<fdomain_client::Vmo>,
        mut ldsvc: Option<fdomain_client::fidl::ClientEnd<fdomain_fuchsia_ldsvc::LoaderMarker>>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<ResolverResolveResponse>(
            (status, executable, ldsvc),
            self.tx_id,
            0x3c15951efde89c90,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

mod internal {
    use super::*;

    impl fidl::encoding::ResourceTypeMarker for HandleInfo {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for HandleInfo {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            8
        }
    }

    unsafe impl fidl::encoding::Encode<HandleInfo, fdomain_client::fidl::FDomainResourceDialect>
        for &mut HandleInfo
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<HandleInfo>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<HandleInfo, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fidl::encoding::HandleType<fdomain_client::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.id),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fdomain_client::Handle,
                    { fidl::ObjectType::NONE.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<u32, fdomain_client::fidl::FDomainResourceDialect>,
    > fidl::encoding::Encode<HandleInfo, fdomain_client::fidl::FDomainResourceDialect>
        for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<HandleInfo>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect> for HandleInfo {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                handle: fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect),
                id: fidl::new_empty!(u32, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(fidl::encoding::HandleType<fdomain_client::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect, &mut self.handle, decoder, offset + 0, _depth)?;
            fidl::decode!(
                u32,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.id,
                decoder,
                offset + 4,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for LaunchInfo {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for LaunchInfo {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            24
        }
    }

    unsafe impl fidl::encoding::Encode<LaunchInfo, fdomain_client::fidl::FDomainResourceDialect>
        for &mut LaunchInfo
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<LaunchInfo>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<LaunchInfo, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fidl::encoding::HandleType<fdomain_client::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.executable),
                    <fidl::encoding::HandleType<fdomain_client::Job, { fidl::ObjectType::JOB.into_raw() }, 2147483648> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.job),
                    <fidl::encoding::BoundedString<32> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fdomain_client::Vmo,
                    { fidl::ObjectType::VMO.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fdomain_client::Job,
                    { fidl::ObjectType::JOB.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T2: fidl::encoding::Encode<
                fidl::encoding::BoundedString<32>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    > fidl::encoding::Encode<LaunchInfo, fdomain_client::fidl::FDomainResourceDialect>
        for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<LaunchInfo>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            self.2.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect> for LaunchInfo {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                executable: fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect),
                job: fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Job, { fidl::ObjectType::JOB.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect),
                name: fidl::new_empty!(
                    fidl::encoding::BoundedString<32>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(fidl::encoding::HandleType<fdomain_client::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect, &mut self.executable, decoder, offset + 0, _depth)?;
            fidl::decode!(fidl::encoding::HandleType<fdomain_client::Job, { fidl::ObjectType::JOB.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect, &mut self.job, decoder, offset + 4, _depth)?;
            fidl::decode!(
                fidl::encoding::BoundedString<32>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.name,
                decoder,
                offset + 8,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for LauncherAddHandlesRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for LauncherAddHandlesRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            LauncherAddHandlesRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut LauncherAddHandlesRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<LauncherAddHandlesRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<LauncherAddHandlesRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fidl::encoding::UnboundedVector<HandleInfo> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handles),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::UnboundedVector<HandleInfo>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            LauncherAddHandlesRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<LauncherAddHandlesRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for LauncherAddHandlesRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                handles: fidl::new_empty!(
                    fidl::encoding::UnboundedVector<HandleInfo>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::UnboundedVector<HandleInfo>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.handles,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for LauncherAddNamesRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for LauncherAddNamesRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            LauncherAddNamesRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut LauncherAddNamesRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<LauncherAddNamesRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<LauncherAddNamesRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fidl::encoding::UnboundedVector<NameInfo> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.names),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::UnboundedVector<NameInfo>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            LauncherAddNamesRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<LauncherAddNamesRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for LauncherAddNamesRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                names: fidl::new_empty!(
                    fidl::encoding::UnboundedVector<NameInfo>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::UnboundedVector<NameInfo>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.names,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for LauncherCreateWithoutStartingRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for LauncherCreateWithoutStartingRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            24
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            LauncherCreateWithoutStartingRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut LauncherCreateWithoutStartingRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<LauncherCreateWithoutStartingRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                LauncherCreateWithoutStartingRequest,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (<LaunchInfo as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.info,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<LaunchInfo, fdomain_client::fidl::FDomainResourceDialect>,
    >
        fidl::encoding::Encode<
            LauncherCreateWithoutStartingRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<LauncherCreateWithoutStartingRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for LauncherCreateWithoutStartingRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                info: fidl::new_empty!(LaunchInfo, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                LaunchInfo,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.info,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for LauncherCreateWithoutStartingResponse {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for LauncherCreateWithoutStartingResponse {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            LauncherCreateWithoutStartingResponse,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut LauncherCreateWithoutStartingResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<LauncherCreateWithoutStartingResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<LauncherCreateWithoutStartingResponse, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <i32 as fidl::encoding::ValueTypeMarker>::borrow(&self.status),
                    <fidl::encoding::Boxed<ProcessStartData> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.data),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<i32, fdomain_client::fidl::FDomainResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::Boxed<ProcessStartData>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            LauncherCreateWithoutStartingResponse,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<LauncherCreateWithoutStartingResponse>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for LauncherCreateWithoutStartingResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                status: fidl::new_empty!(i32, fdomain_client::fidl::FDomainResourceDialect),
                data: fidl::new_empty!(
                    fidl::encoding::Boxed<ProcessStartData>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                i32,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.status,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Boxed<ProcessStartData>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.data,
                decoder,
                offset + 8,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for LauncherLaunchRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for LauncherLaunchRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            24
        }
    }

    unsafe impl
        fidl::encoding::Encode<LauncherLaunchRequest, fdomain_client::fidl::FDomainResourceDialect>
        for &mut LauncherLaunchRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<LauncherLaunchRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                LauncherLaunchRequest,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (<LaunchInfo as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.info,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<LaunchInfo, fdomain_client::fidl::FDomainResourceDialect>,
    >
        fidl::encoding::Encode<LauncherLaunchRequest, fdomain_client::fidl::FDomainResourceDialect>
        for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<LauncherLaunchRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for LauncherLaunchRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                info: fidl::new_empty!(LaunchInfo, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                LaunchInfo,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.info,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for LauncherLaunchResponse {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for LauncherLaunchResponse {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            8
        }
    }

    unsafe impl
        fidl::encoding::Encode<LauncherLaunchResponse, fdomain_client::fidl::FDomainResourceDialect>
        for &mut LauncherLaunchResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<LauncherLaunchResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                LauncherLaunchResponse,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (
                    <i32 as fidl::encoding::ValueTypeMarker>::borrow(&self.status),
                    <fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fdomain_client::Process,
                            { fidl::ObjectType::PROCESS.into_raw() },
                            2147483648,
                        >,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.process
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<i32, fdomain_client::fidl::FDomainResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fdomain_client::Process,
                        { fidl::ObjectType::PROCESS.into_raw() },
                        2147483648,
                    >,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<LauncherLaunchResponse, fdomain_client::fidl::FDomainResourceDialect>
        for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<LauncherLaunchResponse>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for LauncherLaunchResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                status: fidl::new_empty!(i32, fdomain_client::fidl::FDomainResourceDialect),
                process: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fdomain_client::Process,
                            { fidl::ObjectType::PROCESS.into_raw() },
                            2147483648,
                        >,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                i32,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.status,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fdomain_client::Process,
                        { fidl::ObjectType::PROCESS.into_raw() },
                        2147483648,
                    >,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.process,
                decoder,
                offset + 4,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for NameInfo {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for NameInfo {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            24
        }
    }

    unsafe impl fidl::encoding::Encode<NameInfo, fdomain_client::fidl::FDomainResourceDialect>
        for &mut NameInfo
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NameInfo>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<NameInfo, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fidl::encoding::BoundedString<4095> as fidl::encoding::ValueTypeMarker>::borrow(&self.path),
                    <fidl::encoding::Endpoint<fdomain_client::fidl::ClientEnd<fdomain_fuchsia_io::DirectoryMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.directory),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::BoundedString<4095>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<
                    fdomain_client::fidl::ClientEnd<fdomain_fuchsia_io::DirectoryMarker>,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    > fidl::encoding::Encode<NameInfo, fdomain_client::fidl::FDomainResourceDialect> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NameInfo>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect> for NameInfo {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                path: fidl::new_empty!(
                    fidl::encoding::BoundedString<4095>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                directory: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fdomain_client::fidl::ClientEnd<fdomain_fuchsia_io::DirectoryMarker>,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl::encoding::BoundedString<4095>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.path,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<
                    fdomain_client::fidl::ClientEnd<fdomain_fuchsia_io::DirectoryMarker>,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.directory,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ProcessStartData {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ProcessStartData {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            56
        }
    }

    unsafe impl
        fidl::encoding::Encode<ProcessStartData, fdomain_client::fidl::FDomainResourceDialect>
        for &mut ProcessStartData
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ProcessStartData>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ProcessStartData, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fidl::encoding::HandleType<fdomain_client::Process, { fidl::ObjectType::PROCESS.into_raw() }, 2147483648> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.process),
                    <fidl::encoding::HandleType<fdomain_client::Vmar, { fidl::ObjectType::VMAR.into_raw() }, 2147483648> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.root_vmar),
                    <fidl::encoding::HandleType<fdomain_client::Thread, { fidl::ObjectType::THREAD.into_raw() }, 2147483648> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.thread),
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.entry),
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.stack),
                    <fidl::encoding::HandleType<fdomain_client::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.bootstrap),
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.vdso_base),
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.base),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fdomain_client::Process,
                    { fidl::ObjectType::PROCESS.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fdomain_client::Vmar,
                    { fidl::ObjectType::VMAR.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T2: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fdomain_client::Thread,
                    { fidl::ObjectType::THREAD.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T3: fidl::encoding::Encode<u64, fdomain_client::fidl::FDomainResourceDialect>,
        T4: fidl::encoding::Encode<u64, fdomain_client::fidl::FDomainResourceDialect>,
        T5: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fdomain_client::Channel,
                    { fidl::ObjectType::CHANNEL.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T6: fidl::encoding::Encode<u64, fdomain_client::fidl::FDomainResourceDialect>,
        T7: fidl::encoding::Encode<u64, fdomain_client::fidl::FDomainResourceDialect>,
    > fidl::encoding::Encode<ProcessStartData, fdomain_client::fidl::FDomainResourceDialect>
        for (T0, T1, T2, T3, T4, T5, T6, T7)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ProcessStartData>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
                (ptr as *mut u64).write_unaligned(0);
            }
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(32);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            self.2.encode(encoder, offset + 8, depth)?;
            self.3.encode(encoder, offset + 16, depth)?;
            self.4.encode(encoder, offset + 24, depth)?;
            self.5.encode(encoder, offset + 32, depth)?;
            self.6.encode(encoder, offset + 40, depth)?;
            self.7.encode(encoder, offset + 48, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for ProcessStartData
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                process: fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Process, { fidl::ObjectType::PROCESS.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect),
                root_vmar: fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Vmar, { fidl::ObjectType::VMAR.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect),
                thread: fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Thread, { fidl::ObjectType::THREAD.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect),
                entry: fidl::new_empty!(u64, fdomain_client::fidl::FDomainResourceDialect),
                stack: fidl::new_empty!(u64, fdomain_client::fidl::FDomainResourceDialect),
                bootstrap: fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect),
                vdso_base: fidl::new_empty!(u64, fdomain_client::fidl::FDomainResourceDialect),
                base: fidl::new_empty!(u64, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(32) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(fidl::encoding::HandleType<fdomain_client::Process, { fidl::ObjectType::PROCESS.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect, &mut self.process, decoder, offset + 0, _depth)?;
            fidl::decode!(fidl::encoding::HandleType<fdomain_client::Vmar, { fidl::ObjectType::VMAR.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect, &mut self.root_vmar, decoder, offset + 4, _depth)?;
            fidl::decode!(fidl::encoding::HandleType<fdomain_client::Thread, { fidl::ObjectType::THREAD.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect, &mut self.thread, decoder, offset + 8, _depth)?;
            fidl::decode!(
                u64,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.entry,
                decoder,
                offset + 16,
                _depth
            )?;
            fidl::decode!(
                u64,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.stack,
                decoder,
                offset + 24,
                _depth
            )?;
            fidl::decode!(fidl::encoding::HandleType<fdomain_client::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect, &mut self.bootstrap, decoder, offset + 32, _depth)?;
            fidl::decode!(
                u64,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.vdso_base,
                decoder,
                offset + 40,
                _depth
            )?;
            fidl::decode!(
                u64,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.base,
                decoder,
                offset + 48,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ResolverResolveResponse {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ResolverResolveResponse {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            12
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            ResolverResolveResponse,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut ResolverResolveResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ResolverResolveResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                ResolverResolveResponse,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (
                    <i32 as fidl::encoding::ValueTypeMarker>::borrow(&self.status),
                    <fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fdomain_client::Vmo,
                            { fidl::ObjectType::VMO.into_raw() },
                            2147483648,
                        >,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.executable
                    ),
                    <fidl::encoding::Optional<
                        fidl::encoding::Endpoint<
                            fdomain_client::fidl::ClientEnd<fdomain_fuchsia_ldsvc::LoaderMarker>,
                        >,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.ldsvc
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<i32, fdomain_client::fidl::FDomainResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fdomain_client::Vmo,
                        { fidl::ObjectType::VMO.into_raw() },
                        2147483648,
                    >,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T2: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::Endpoint<
                        fdomain_client::fidl::ClientEnd<fdomain_fuchsia_ldsvc::LoaderMarker>,
                    >,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            ResolverResolveResponse,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ResolverResolveResponse>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            self.2.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for ResolverResolveResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                status: fidl::new_empty!(i32, fdomain_client::fidl::FDomainResourceDialect),
                executable: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fdomain_client::Vmo,
                            { fidl::ObjectType::VMO.into_raw() },
                            2147483648,
                        >,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                ldsvc: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::Endpoint<
                            fdomain_client::fidl::ClientEnd<fdomain_fuchsia_ldsvc::LoaderMarker>,
                        >,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                i32,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.status,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fdomain_client::Vmo,
                        { fidl::ObjectType::VMO.into_raw() },
                        2147483648,
                    >,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.executable,
                decoder,
                offset + 4,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::Endpoint<
                        fdomain_client::fidl::ClientEnd<fdomain_fuchsia_ldsvc::LoaderMarker>,
                    >,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.ldsvc,
                decoder,
                offset + 8,
                _depth
            )?;
            Ok(())
        }
    }
}