fidl_fuchsia_component_test/

fidl_fuchsia_component_test.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 fidl::client::QueryResponseFut;
use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
use fidl::endpoints::{ControlHandle as _, Responder as _};
pub use fidl_fuchsia_component_test_common::*;
use futures::future::{self, MaybeDone, TryFutureExt};
use zx_status;

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct BuilderBuildRequest {
    pub runner: fidl::endpoints::ClientEnd<fidl_fuchsia_component_runner::ComponentRunnerMarker>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for BuilderBuildRequest {}

/// The contents of a directory that should be provided by the realm builder
/// server.
#[derive(Debug, PartialEq)]
pub struct DirectoryContents {
    pub entries: Vec<DirectoryEntry>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for DirectoryContents {}

/// An entry in a directory.
#[derive(Debug, PartialEq)]
pub struct DirectoryEntry {
    /// The path to the file. Valid examples include `foo.txt` and
    /// `foo/bar.json`.
    pub file_path: String,
    /// The contents of the file.
    pub file_contents: fidl_fuchsia_mem::Buffer,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for DirectoryEntry {}

#[derive(Debug, PartialEq)]
pub struct RealmAddChildRealmFromDeclRequest {
    /// The name of the child realm that is being added.
    pub name: String,
    /// The component's declaration.
    pub decl: fidl_fuchsia_component_decl::Component,
    /// Additional properties for the child.
    pub options: ChildOptions,
    /// The server end of the `Realm` channel that will be used to build the
    /// sub-realm.
    pub child_realm: fidl::endpoints::ServerEnd<RealmMarker>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for RealmAddChildRealmFromDeclRequest
{
}

#[derive(Debug, PartialEq)]
pub struct RealmAddChildRealmFromRelativeUrlRequest {
    /// The name of the child realm that is being added.
    pub name: String,
    /// The relative (fragment-only) URL.
    pub relative_url: String,
    /// Additional properties for the child.
    pub options: ChildOptions,
    /// The server end of the `Realm` channel that will be used to build the
    /// sub-realm.
    pub child_realm: fidl::endpoints::ServerEnd<RealmMarker>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for RealmAddChildRealmFromRelativeUrlRequest
{
}

#[derive(Debug, PartialEq)]
pub struct RealmAddChildRealmRequest {
    /// The name of the child realm that is being added.
    pub name: String,
    /// Additional properties for the child.
    pub options: ChildOptions,
    /// The server end of the `Realm` channel that will be used to build the
    /// sub-realm.
    pub child_realm: fidl::endpoints::ServerEnd<RealmMarker>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for RealmAddChildRealmRequest {}

#[derive(Debug, PartialEq)]
pub struct RealmAddStorageRequest {
    /// The name of the storage capability.
    pub name: String,
    /// The target that this storage capability will be offered to.
    pub to: Vec<fidl_fuchsia_component_decl::Ref>,
    /// The server end to connect to this storage capability's
    /// `fuchsia.sys2.StorageAdmin` protocol.
    pub storage_admin:
        Option<fidl::endpoints::ServerEnd<fidl_fuchsia_component::StorageAdminMarker>>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for RealmAddStorageRequest {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RealmBuilderFactoryCreateFromRelativeUrlRequest {
    pub pkg_dir_handle: fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
    pub relative_url: String,
    pub realm_server_end: fidl::endpoints::ServerEnd<RealmMarker>,
    pub builder_server_end: fidl::endpoints::ServerEnd<BuilderMarker>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for RealmBuilderFactoryCreateFromRelativeUrlRequest
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RealmBuilderFactoryCreateRequest {
    pub pkg_dir_handle: fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
    pub realm_server_end: fidl::endpoints::ServerEnd<RealmMarker>,
    pub builder_server_end: fidl::endpoints::ServerEnd<BuilderMarker>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for RealmBuilderFactoryCreateRequest
{
}

#[derive(Debug, PartialEq)]
pub struct RealmReadOnlyDirectoryRequest {
    /// The name of the directory capability.
    pub name: String,
    /// The target that this directory will be offered to.
    pub to: Vec<fidl_fuchsia_component_decl::Ref>,
    /// The contents of the directory.
    pub directory_contents: DirectoryContents,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for RealmReadOnlyDirectoryRequest
{
}

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

impl fidl::endpoints::ProtocolMarker for BuilderMarker {
    type Proxy = BuilderProxy;
    type RequestStream = BuilderRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = BuilderSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.component.test.Builder";
}
impl fidl::endpoints::DiscoverableProtocolMarker for BuilderMarker {}
pub type BuilderBuildResult = Result<String, RealmBuilderError>;

pub trait BuilderProxyInterface: Send + Sync {
    type BuildResponseFut: std::future::Future<Output = Result<BuilderBuildResult, fidl::Error>>
        + Send;
    fn r#build(
        &self,
        runner: fidl::endpoints::ClientEnd<fidl_fuchsia_component_runner::ComponentRunnerMarker>,
    ) -> Self::BuildResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct BuilderSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for BuilderSynchronousProxy {
    type Proxy = BuilderProxy;
    type Protocol = BuilderMarker;

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

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

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

#[cfg(target_os = "fuchsia")]
impl BuilderSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<BuilderEvent, fidl::Error> {
        BuilderEvent::decode(self.client.wait_for_event::<BuilderMarker>(deadline)?)
    }

    /// Assembles the realm being constructed and returns the URL for the root
    /// component in the realm, which may then be used to create a new component
    /// in any collection where fuchsia-test-component is properly set up. Once
    /// this is called, any Realm channels for the realm will no longer be
    /// usable. The `runner` argument must be provided if the `AddLocalChild`
    /// function has been used in this realm, as this runner channel will be
    /// used to inform the client when to start and stop running any local
    /// component implementations.
    ///
    /// Errors:
    /// - `INVALID_COMPONENT_DECL`: A component declaration failed validaiton.
    /// - `BUILD_ALREADY_CALLED`: The `Build` function has been called multiple
    ///   times on this channel.
    pub fn r#build(
        &self,
        mut runner: fidl::endpoints::ClientEnd<
            fidl_fuchsia_component_runner::ComponentRunnerMarker,
        >,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BuilderBuildResult, fidl::Error> {
        let _response = self.client.send_query::<BuilderBuildRequest, fidl::encoding::ResultType<
            BuilderBuildResponse,
            RealmBuilderError,
        >, BuilderMarker>(
            (runner,),
            0x172ba0923ec91575,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.root_component_url))
    }
}

#[cfg(target_os = "fuchsia")]
impl From<BuilderSynchronousProxy> for zx::NullableHandle {
    fn from(value: BuilderSynchronousProxy) -> Self {
        value.into_channel().into()
    }
}

#[cfg(target_os = "fuchsia")]
impl From<fidl::Channel> for BuilderSynchronousProxy {
    fn from(value: fidl::Channel) -> Self {
        Self::new(value)
    }
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::FromClient for BuilderSynchronousProxy {
    type Protocol = BuilderMarker;

    fn from_client(value: fidl::endpoints::ClientEnd<BuilderMarker>) -> Self {
        Self::new(value.into_channel())
    }
}

#[derive(Debug, Clone)]
pub struct BuilderProxy {
    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl fidl::endpoints::Proxy for BuilderProxy {
    type Protocol = BuilderMarker;

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

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

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl BuilderProxy {
    /// Create a new Proxy for fuchsia.component.test/Builder.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <BuilderMarker as fidl::endpoints::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) -> BuilderEventStream {
        BuilderEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Assembles the realm being constructed and returns the URL for the root
    /// component in the realm, which may then be used to create a new component
    /// in any collection where fuchsia-test-component is properly set up. Once
    /// this is called, any Realm channels for the realm will no longer be
    /// usable. The `runner` argument must be provided if the `AddLocalChild`
    /// function has been used in this realm, as this runner channel will be
    /// used to inform the client when to start and stop running any local
    /// component implementations.
    ///
    /// Errors:
    /// - `INVALID_COMPONENT_DECL`: A component declaration failed validaiton.
    /// - `BUILD_ALREADY_CALLED`: The `Build` function has been called multiple
    ///   times on this channel.
    pub fn r#build(
        &self,
        mut runner: fidl::endpoints::ClientEnd<
            fidl_fuchsia_component_runner::ComponentRunnerMarker,
        >,
    ) -> fidl::client::QueryResponseFut<
        BuilderBuildResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BuilderProxyInterface::r#build(self, runner)
    }
}

impl BuilderProxyInterface for BuilderProxy {
    type BuildResponseFut = fidl::client::QueryResponseFut<
        BuilderBuildResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#build(
        &self,
        mut runner: fidl::endpoints::ClientEnd<
            fidl_fuchsia_component_runner::ComponentRunnerMarker,
        >,
    ) -> Self::BuildResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BuilderBuildResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<BuilderBuildResponse, RealmBuilderError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x172ba0923ec91575,
            >(_buf?)?;
            Ok(_response.map(|x| x.root_component_url))
        }
        self.client.send_query_and_decode::<BuilderBuildRequest, BuilderBuildResult>(
            (runner,),
            0x172ba0923ec91575,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

pub struct BuilderEventStream {
    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

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

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

impl futures::Stream for BuilderEventStream {
    type Item = Result<BuilderEvent, 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(BuilderEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

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

impl BuilderEvent {
    /// Decodes a message buffer as a [`BuilderEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<BuilderEvent, 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: <BuilderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.component.test/Builder.
pub struct BuilderRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for BuilderRequestStream {
    type Protocol = BuilderMarker;
    type ControlHandle = BuilderControlHandle;

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

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

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

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

impl futures::Stream for BuilderRequestStream {
    type Item = Result<BuilderRequest, 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 BuilderRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |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(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(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 {
                    0x172ba0923ec91575 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BuilderBuildRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BuilderBuildRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BuilderControlHandle { inner: this.inner.clone() };
                        Ok(BuilderRequest::Build {
                            runner: req.runner,

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

#[derive(Debug)]
pub enum BuilderRequest {
    /// Assembles the realm being constructed and returns the URL for the root
    /// component in the realm, which may then be used to create a new component
    /// in any collection where fuchsia-test-component is properly set up. Once
    /// this is called, any Realm channels for the realm will no longer be
    /// usable. The `runner` argument must be provided if the `AddLocalChild`
    /// function has been used in this realm, as this runner channel will be
    /// used to inform the client when to start and stop running any local
    /// component implementations.
    ///
    /// Errors:
    /// - `INVALID_COMPONENT_DECL`: A component declaration failed validaiton.
    /// - `BUILD_ALREADY_CALLED`: The `Build` function has been called multiple
    ///   times on this channel.
    Build {
        runner: fidl::endpoints::ClientEnd<fidl_fuchsia_component_runner::ComponentRunnerMarker>,
        responder: BuilderBuildResponder,
    },
}

impl BuilderRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_build(
        self,
    ) -> Option<(
        fidl::endpoints::ClientEnd<fidl_fuchsia_component_runner::ComponentRunnerMarker>,
        BuilderBuildResponder,
    )> {
        if let BuilderRequest::Build { runner, responder } = self {
            Some((runner, responder))
        } else {
            None
        }
    }

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

#[derive(Debug, Clone)]
pub struct BuilderControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl BuilderControlHandle {
    pub fn shutdown_with_epitaph(&self, status: impl Into<fidl::Epitaph>) {
        self.inner.shutdown_with_epitaph(status.into())
    }
}

impl fidl::endpoints::ControlHandle for BuilderControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl BuilderControlHandle {}

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

/// Set the the channel to be shutdown (see [`BuilderControlHandle::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 BuilderBuildResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BuilderBuildResponder {
    type ControlHandle = BuilderControlHandle;

    fn control_handle(&self) -> &BuilderControlHandle {
        &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 BuilderBuildResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<&str, RealmBuilderError>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        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 result: Result<&str, RealmBuilderError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<&str, RealmBuilderError>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<BuilderBuildResponse, RealmBuilderError>>(
                result.map(|root_component_url| (root_component_url,)),
                self.tx_id,
                0x172ba0923ec91575,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

impl fidl::endpoints::ProtocolMarker for RealmMarker {
    type Proxy = RealmProxy;
    type RequestStream = RealmRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = RealmSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.component.test.Realm";
}
impl fidl::endpoints::DiscoverableProtocolMarker for RealmMarker {}
pub type RealmAddChildResult = Result<(), RealmBuilderError>;
pub type RealmAddChildFromDeclResult = Result<(), RealmBuilderError>;
pub type RealmAddLocalChildResult = Result<(), RealmBuilderError>;
pub type RealmAddChildRealmResult = Result<(), RealmBuilderError>;
pub type RealmAddChildRealmFromRelativeUrlResult = Result<(), RealmBuilderError>;
pub type RealmAddChildRealmFromDeclResult = Result<(), RealmBuilderError>;
pub type RealmGetComponentDeclResult =
    Result<fidl_fuchsia_component_decl::Component, RealmBuilderError>;
pub type RealmReplaceComponentDeclResult = Result<(), RealmBuilderError>;
pub type RealmGetRealmDeclResult =
    Result<fidl_fuchsia_component_decl::Component, RealmBuilderError>;
pub type RealmReplaceRealmDeclResult = Result<(), RealmBuilderError>;
pub type RealmUseNestedComponentManagerResult = Result<(), RealmBuilderError>;
pub type RealmAddRouteResult = Result<(), RealmBuilderError>;
pub type RealmAddRouteFromDictionaryResult = Result<(), RealmBuilderError>;
pub type RealmReadOnlyDirectoryResult = Result<(), RealmBuilderError>;
pub type RealmAddStorageResult = Result<(), RealmBuilderError>;
pub type RealmInitMutableConfigFromPackageResult = Result<(), RealmBuilderError>;
pub type RealmInitMutableConfigToEmptyResult = Result<(), RealmBuilderError>;
pub type RealmAddCapabilityResult = Result<(), RealmBuilderError>;
pub type RealmAddCollectionResult = Result<(), RealmBuilderError>;
pub type RealmAddEnvironmentResult = Result<(), RealmBuilderError>;
pub type RealmSetConfigValueResult = Result<(), RealmBuilderError>;

pub trait RealmProxyInterface: Send + Sync {
    type AddChildResponseFut: std::future::Future<Output = Result<RealmAddChildResult, fidl::Error>>
        + Send;
    fn r#add_child(
        &self,
        name: &str,
        url: &str,
        options: &ChildOptions,
    ) -> Self::AddChildResponseFut;
    type AddChildFromDeclResponseFut: std::future::Future<Output = Result<RealmAddChildFromDeclResult, fidl::Error>>
        + Send;
    fn r#add_child_from_decl(
        &self,
        name: &str,
        decl: &fidl_fuchsia_component_decl::Component,
        options: &ChildOptions,
    ) -> Self::AddChildFromDeclResponseFut;
    type AddLocalChildResponseFut: std::future::Future<Output = Result<RealmAddLocalChildResult, fidl::Error>>
        + Send;
    fn r#add_local_child(
        &self,
        name: &str,
        options: &ChildOptions,
    ) -> Self::AddLocalChildResponseFut;
    type AddChildRealmResponseFut: std::future::Future<Output = Result<RealmAddChildRealmResult, fidl::Error>>
        + Send;
    fn r#add_child_realm(
        &self,
        name: &str,
        options: &ChildOptions,
        child_realm: fidl::endpoints::ServerEnd<RealmMarker>,
    ) -> Self::AddChildRealmResponseFut;
    type AddChildRealmFromRelativeUrlResponseFut: std::future::Future<Output = Result<RealmAddChildRealmFromRelativeUrlResult, fidl::Error>>
        + Send;
    fn r#add_child_realm_from_relative_url(
        &self,
        name: &str,
        relative_url: &str,
        options: &ChildOptions,
        child_realm: fidl::endpoints::ServerEnd<RealmMarker>,
    ) -> Self::AddChildRealmFromRelativeUrlResponseFut;
    type AddChildRealmFromDeclResponseFut: std::future::Future<Output = Result<RealmAddChildRealmFromDeclResult, fidl::Error>>
        + Send;
    fn r#add_child_realm_from_decl(
        &self,
        name: &str,
        decl: &fidl_fuchsia_component_decl::Component,
        options: &ChildOptions,
        child_realm: fidl::endpoints::ServerEnd<RealmMarker>,
    ) -> Self::AddChildRealmFromDeclResponseFut;
    type GetComponentDeclResponseFut: std::future::Future<Output = Result<RealmGetComponentDeclResult, fidl::Error>>
        + Send;
    fn r#get_component_decl(&self, name: &str) -> Self::GetComponentDeclResponseFut;
    type ReplaceComponentDeclResponseFut: std::future::Future<Output = Result<RealmReplaceComponentDeclResult, fidl::Error>>
        + Send;
    fn r#replace_component_decl(
        &self,
        name: &str,
        component_decl: &fidl_fuchsia_component_decl::Component,
    ) -> Self::ReplaceComponentDeclResponseFut;
    type GetRealmDeclResponseFut: std::future::Future<Output = Result<RealmGetRealmDeclResult, fidl::Error>>
        + Send;
    fn r#get_realm_decl(&self) -> Self::GetRealmDeclResponseFut;
    type ReplaceRealmDeclResponseFut: std::future::Future<Output = Result<RealmReplaceRealmDeclResult, fidl::Error>>
        + Send;
    fn r#replace_realm_decl(
        &self,
        component_decl: &fidl_fuchsia_component_decl::Component,
    ) -> Self::ReplaceRealmDeclResponseFut;
    type UseNestedComponentManagerResponseFut: std::future::Future<Output = Result<RealmUseNestedComponentManagerResult, fidl::Error>>
        + Send;
    fn r#use_nested_component_manager(
        &self,
        component_manager_relative_url: &str,
    ) -> Self::UseNestedComponentManagerResponseFut;
    type AddRouteResponseFut: std::future::Future<Output = Result<RealmAddRouteResult, fidl::Error>>
        + Send;
    fn r#add_route(
        &self,
        capabilities: &[Capability],
        from: &fidl_fuchsia_component_decl::Ref,
        to: &[fidl_fuchsia_component_decl::Ref],
    ) -> Self::AddRouteResponseFut;
    type AddRouteFromDictionaryResponseFut: std::future::Future<Output = Result<RealmAddRouteFromDictionaryResult, fidl::Error>>
        + Send;
    fn r#add_route_from_dictionary(
        &self,
        capabilities: &[Capability],
        from: &fidl_fuchsia_component_decl::Ref,
        from_dictionary: &str,
        to: &[fidl_fuchsia_component_decl::Ref],
    ) -> Self::AddRouteFromDictionaryResponseFut;
    type ReadOnlyDirectoryResponseFut: std::future::Future<Output = Result<RealmReadOnlyDirectoryResult, fidl::Error>>
        + Send;
    fn r#read_only_directory(
        &self,
        name: &str,
        to: &[fidl_fuchsia_component_decl::Ref],
        directory_contents: DirectoryContents,
    ) -> Self::ReadOnlyDirectoryResponseFut;
    type AddStorageResponseFut: std::future::Future<Output = Result<RealmAddStorageResult, fidl::Error>>
        + Send;
    fn r#add_storage(
        &self,
        name: &str,
        to: &[fidl_fuchsia_component_decl::Ref],
        storage_admin: Option<
            fidl::endpoints::ServerEnd<fidl_fuchsia_component::StorageAdminMarker>,
        >,
    ) -> Self::AddStorageResponseFut;
    type InitMutableConfigFromPackageResponseFut: std::future::Future<Output = Result<RealmInitMutableConfigFromPackageResult, fidl::Error>>
        + Send;
    fn r#init_mutable_config_from_package(
        &self,
        name: &str,
    ) -> Self::InitMutableConfigFromPackageResponseFut;
    type InitMutableConfigToEmptyResponseFut: std::future::Future<Output = Result<RealmInitMutableConfigToEmptyResult, fidl::Error>>
        + Send;
    fn r#init_mutable_config_to_empty(
        &self,
        name: &str,
    ) -> Self::InitMutableConfigToEmptyResponseFut;
    type AddCapabilityResponseFut: std::future::Future<Output = Result<RealmAddCapabilityResult, fidl::Error>>
        + Send;
    fn r#add_capability(
        &self,
        capability: &fidl_fuchsia_component_decl::Capability,
    ) -> Self::AddCapabilityResponseFut;
    type AddCollectionResponseFut: std::future::Future<Output = Result<RealmAddCollectionResult, fidl::Error>>
        + Send;
    fn r#add_collection(
        &self,
        collection: &fidl_fuchsia_component_decl::Collection,
    ) -> Self::AddCollectionResponseFut;
    type AddEnvironmentResponseFut: std::future::Future<Output = Result<RealmAddEnvironmentResult, fidl::Error>>
        + Send;
    fn r#add_environment(
        &self,
        environment: &fidl_fuchsia_component_decl::Environment,
    ) -> Self::AddEnvironmentResponseFut;
    type SetConfigValueResponseFut: std::future::Future<Output = Result<RealmSetConfigValueResult, fidl::Error>>
        + Send;
    fn r#set_config_value(
        &self,
        name: &str,
        key: &str,
        value: &fidl_fuchsia_component_decl::ConfigValueSpec,
    ) -> Self::SetConfigValueResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct RealmSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for RealmSynchronousProxy {
    type Proxy = RealmProxy;
    type Protocol = RealmMarker;

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

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

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

#[cfg(target_os = "fuchsia")]
impl RealmSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<RealmEvent, fidl::Error> {
        RealmEvent::decode(self.client.wait_for_event::<RealmMarker>(deadline)?)
    }

    /// Adds a component to the realm.
    ///
    /// The `url` can be in one of the following formats:
    ///
    /// - an absolute component URL (such as,
    ///   "fuchsia-pkg://fuchsia.com/some-package#meta/some-component.cm")
    /// - a relative path component URL to a subpackaged component (like,
    ///   "some-subpackage#meta/subpackaged-component.cm"); or
    /// - a relative fragment-only URL (like, `#meta/other-component.cm`;
    ///   see https://fuchsia.dev/fuchsia-src/reference/components/url#relative-fragment-only)
    ///   indicating the path to a component manifest in the `pkg_dir` supplied
    ///   to `RealmBuilderFactory::Create*()`.
    ///
    /// The realm builder client typically passes a handle to its own `/pkg`
    /// directory, and bundles the `other-component` into the same package.
    ///
    /// Of the three URL types, _only_ component declarations added via the
    /// fragment-only URL can be modified, via
    /// `GetComponentDecl`/`ReplaceComponentDecl` because realm builder actually
    /// performs its own component resolution from the component's manifest and
    /// files bundled in the provided `pkg_dir` (typically from the package
    /// shared by the realm builder client component and the components added
    /// via fragment-only URL).
    ///
    /// Errors:
    /// - `CHILD_ALREADY_EXISTS`: this realm already contains a child with the
    ///   given name.
    /// - `INVALID_MANIFEST_EXTENSION`: `url` does not end with `.cm`
    /// - `DECL_NOT_FOUND`: The test package does not contain the component
    ///   declaration referenced by a fragment-only component URL.
    /// - `DECL_READ_ERROR`: Encountered an I/O error when attempting to read a
    ///   component declaration referenced by a fragment-only component URL from
    ///   the test package.
    /// - `BUILD_ALREADY_CALLED`: The `Builder.Build` function has been called
    ///   for this realm, and thus this `Realm` channel can no longer be used.
    pub fn r#add_child(
        &self,
        mut name: &str,
        mut url: &str,
        mut options: &ChildOptions,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RealmAddChildResult, fidl::Error> {
        let _response = self.client.send_query::<RealmAddChildRequest, fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            RealmBuilderError,
        >, RealmMarker>(
            (name, url, options),
            0x3f6c07627303d801,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Adds a component to this realm whose declaration is set to `decl`. When
    /// launched, the component will share the test package as its package
    /// directory, and may access any resources from it.
    ///
    /// Errors:
    /// - `CHILD_ALREADY_EXISTS`: this realm already contains a child with the
    ///   given name.
    /// - `INVALID_COMPONENT_DECL`: `decl` failed validation.
    /// - `BUILD_ALREADY_CALLED`: The `Builder.Build` function has been called
    ///   for this realm, and thus this `Realm` channel can no longer be used.
    pub fn r#add_child_from_decl(
        &self,
        mut name: &str,
        mut decl: &fidl_fuchsia_component_decl::Component,
        mut options: &ChildOptions,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RealmAddChildFromDeclResult, fidl::Error> {
        let _response =
            self.client.send_query::<RealmAddChildFromDeclRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                RealmBuilderError,
            >, RealmMarker>(
                (name, decl, options),
                0x3950ad500258156d,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Adds a component to the realm whose implementation will be provided by
    /// the client. When this component should be started, the runner channel
    /// passed into `Build` will receive a start request for a component whose
    /// `ProgramDecl` contains the moniker from the root of the
    /// constructed realm for the child that is to be run under the `program`
    /// key `LOCAL_COMPONENT_NAME`.
    ///
    /// Errors:
    /// - `CHILD_ALREADY_EXISTS`: this realm already contains a child with the
    ///   given name.
    /// - `BUILD_ALREADY_CALLED`: The `Builder.Build` function has been called
    ///   for this realm, and thus this `Realm` channel can no longer be used.
    pub fn r#add_local_child(
        &self,
        mut name: &str,
        mut options: &ChildOptions,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RealmAddLocalChildResult, fidl::Error> {
        let _response =
            self.client.send_query::<RealmAddLocalChildRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                RealmBuilderError,
            >, RealmMarker>(
                (name, options),
                0x3249817bae10abbb,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Adds a child realm which can be built with the client end of
    /// `child_realm`.
    ///
    /// Errors:
    /// - `CHILD_ALREADY_EXISTS`: this realm already contains a child with the
    ///   given name.
    /// - `BUILD_ALREADY_CALLED`: The `Builder.Build` function has been called
    ///   for this realm, and thus this `Realm` channel can no longer be used.
    pub fn r#add_child_realm(
        &self,
        mut name: &str,
        mut options: &ChildOptions,
        mut child_realm: fidl::endpoints::ServerEnd<RealmMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RealmAddChildRealmResult, fidl::Error> {
        let _response =
            self.client.send_query::<RealmAddChildRealmRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                RealmBuilderError,
            >, RealmMarker>(
                (name, options, child_realm),
                0x3fdf98db373b9458,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Adds a child realm which can be built with the client end of
    /// `child_realm`, and whose contents are initialized from `relative_url`.
    /// `relative_url` must be a fragment-only URL.
    pub fn r#add_child_realm_from_relative_url(
        &self,
        mut name: &str,
        mut relative_url: &str,
        mut options: &ChildOptions,
        mut child_realm: fidl::endpoints::ServerEnd<RealmMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RealmAddChildRealmFromRelativeUrlResult, fidl::Error> {
        let _response = self.client.send_query::<
            RealmAddChildRealmFromRelativeUrlRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, RealmBuilderError>,
            RealmMarker,
        >(
            (name, relative_url, options, child_realm,),
            0x44c34c8dcbe06abb,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Adds a child realm which can be built with the client end of
    /// `child_realm`, and whose contents are initialized from `decl`.
    pub fn r#add_child_realm_from_decl(
        &self,
        mut name: &str,
        mut decl: &fidl_fuchsia_component_decl::Component,
        mut options: &ChildOptions,
        mut child_realm: fidl::endpoints::ServerEnd<RealmMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RealmAddChildRealmFromDeclResult, fidl::Error> {
        let _response = self.client.send_query::<
            RealmAddChildRealmFromDeclRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, RealmBuilderError>,
            RealmMarker,
        >(
            (name, decl, options, child_realm,),
            0x142e5c326732862e,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Returns the component decl for the given component. `name` must refer to
    /// a component that is one of the following:
    ///
    /// - A component with a local implementation
    /// - A legacy component
    /// - A component added with a fragment-only URL (typically, components
    ///   bundled in the same package as the realm builder client, sharing the
    ///   same `/pkg` directory, for example, `#meta/other-component.cm`; see
    ///   https://fuchsia.dev/fuchsia-src/reference/components/url#relative-fragment-only)
    /// - An automatically generated realm (ex: the root)
    ///
    /// Errors:
    /// - `NO_SUCH_CHILD`: This realm does not contain a child with the given
    ///   name.
    /// - `CHILD_DECL_NOT_VISIBLE`: The component decl cannot be fetched for
    ///   the referenced child, because the child was added to the realm using
    ///   a modern (not legacy) absolute URL or subpackaged component's relative
    ///   path URL.
    /// - `BUILD_ALREADY_CALLED`: The `Builder.Build` function has been called
    ///   for this realm, and thus this `Realm` channel can no longer be used.
    pub fn r#get_component_decl(
        &self,
        mut name: &str,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RealmGetComponentDeclResult, fidl::Error> {
        let _response =
            self.client.send_query::<RealmGetComponentDeclRequest, fidl::encoding::ResultType<
                RealmGetComponentDeclResponse,
                RealmBuilderError,
            >, RealmMarker>(
                (name,),
                0x320832af6a4cbac6,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.component_decl))
    }

    /// Replaces the component decl for the given component. `name` must
    /// refer to a component that is one of the following:
    ///
    /// - A component with a local implementation
    /// - A legacy component
    /// - A component added with a fragment-only URL (typically, components
    ///   bundled in the same package as the realm builder client, sharing the
    ///   same `/pkg` directory, for example, `#meta/other-component.cm`; see
    ///   https://fuchsia.dev/fuchsia-src/reference/components/url#relative-fragment-only)
    /// - An automatically generated realm (ex: the root)
    ///
    /// Errors:
    /// - `NO_SUCH_CHILD`: This realm does not contain a child with the given
    ///   name.
    /// - `CHILD_ALREADY_EXISTS`: The component whose decl is being replaced has
    ///   had a child added to it through realm builder with the same name as an
    ///   element in `component_decl.children`.
    /// - `CHILD_DECL_NOT_VISIBLE`: The component decl cannot be manipulated for
    ///   the referenced child, because the child was added to the realm using
    ///   an absolute (not relative) and modern (not legacy) URL.
    /// - `INVALID_COMPONENT_DECL`: `component_decl` failed validation.
    /// - `BUILD_ALREADY_CALLED`: The `Builder.Build` function has been called
    ///   for this realm, and thus this `Realm` channel can no longer be used.
    pub fn r#replace_component_decl(
        &self,
        mut name: &str,
        mut component_decl: &fidl_fuchsia_component_decl::Component,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RealmReplaceComponentDeclResult, fidl::Error> {
        let _response =
            self.client.send_query::<RealmReplaceComponentDeclRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                RealmBuilderError,
            >, RealmMarker>(
                (name, component_decl),
                0x59cecf31b314cd5f,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Returns the component decl for this realm.
    ///
    /// Errors:
    /// - `BUILD_ALREADY_CALLED`: The `Builder.Build` function has been called
    ///   for this realm, and thus this `Realm` channel can no longer be used.
    pub fn r#get_realm_decl(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RealmGetRealmDeclResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<RealmGetRealmDeclResponse, RealmBuilderError>,
            RealmMarker,
        >(
            (),
            0x46fa05b17bd64269,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.component_decl))
    }

    /// Replaces the component decl for this realm.
    ///
    /// Errors:
    /// - `INVALID_COMPONENT_DECL`: `component_decl` failed validation.
    /// - `BUILD_ALREADY_CALLED`: The `Builder.Build` function has been called
    ///   for this realm, and thus this `Realm` channel can no longer be used.
    pub fn r#replace_realm_decl(
        &self,
        mut component_decl: &fidl_fuchsia_component_decl::Component,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RealmReplaceRealmDeclResult, fidl::Error> {
        let _response =
            self.client.send_query::<RealmReplaceRealmDeclRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                RealmBuilderError,
            >, RealmMarker>(
                (component_decl,),
                0x48fcba4ac1338da9,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Inform the realm builder server that this realm is using a nested component manager. It's
    /// expected that the client library has already replaced the realm's declaration with a
    /// passthrough component manager declaration, with the exception of the root url.
    /// This method will arrange for [Builder.Build] to install the realm's generated url as the
    /// root url in this component manager.
    pub fn r#use_nested_component_manager(
        &self,
        mut component_manager_relative_url: &str,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RealmUseNestedComponentManagerResult, fidl::Error> {
        let _response = self.client.send_query::<
            RealmUseNestedComponentManagerRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, RealmBuilderError>,
            RealmMarker,
        >(
            (component_manager_relative_url,),
            0x64bd27482f3dcc,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Identical to `AddRouteFromDictionary`, except it does not accept `from_dictionary` which
    /// it always sets to ".".
    pub fn r#add_route(
        &self,
        mut capabilities: &[Capability],
        mut from: &fidl_fuchsia_component_decl::Ref,
        mut to: &[fidl_fuchsia_component_decl::Ref],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RealmAddRouteResult, fidl::Error> {
        let _response = self.client.send_query::<RealmAddRouteRequest, fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            RealmBuilderError,
        >, RealmMarker>(
            (capabilities, from, to),
            0x9d523295be53a0a,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Mutates component manifests in the realm such that every component in
    /// `to` will have a valid capability route for each item in `capabilities`
    /// provided by `from`.
    ///
    /// Errors:
    /// - `NO_SUCH_SOURCE`: `from` references a non-existent child.
    /// - `NO_SUCH_TARGET`: `to` references a non-existent child.
    /// - `CAPABILITIES_EMPTY`: `capabilities` is empty.
    /// - `TARGETS_EMPTY`: `to` is empty.
    /// - `SOURCE_AND_TARGET_MATCH`: `from` is equal to one of the elements in
    ///   `to`.
    /// - `INVALID_COMPONENT_DECL`: The requested route caused one of the
    ///   involved manifests to fail validation.
    /// - `BUILD_ALREADY_CALLED`: The `Builder.Build` function has been called
    ///   for this realm, and thus this `Realm` channel can no longer be used.
    pub fn r#add_route_from_dictionary(
        &self,
        mut capabilities: &[Capability],
        mut from: &fidl_fuchsia_component_decl::Ref,
        mut from_dictionary: &str,
        mut to: &[fidl_fuchsia_component_decl::Ref],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RealmAddRouteFromDictionaryResult, fidl::Error> {
        let _response = self.client.send_query::<
            RealmAddRouteFromDictionaryRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, RealmBuilderError>,
            RealmMarker,
        >(
            (capabilities, from, from_dictionary, to,),
            0x21fac42c3e1d14d2,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Offers a directory capability to a component in this realm. The
    /// directory will be read-only (i.e. have `r*` rights), and will have the
    /// contents described in `directory_contents`.
    ///
    /// Errors:
    /// - `NO_SUCH_TARGET`: `offer-to` references a non-existent child.
    /// - `BUILD_ALREADY_CALLED`: The `Builder.Build` function has been called
    ///   for this realm, and thus this `Realm` channel can no longer be used.
    pub fn r#read_only_directory(
        &self,
        mut name: &str,
        mut to: &[fidl_fuchsia_component_decl::Ref],
        mut directory_contents: DirectoryContents,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RealmReadOnlyDirectoryResult, fidl::Error> {
        let _response =
            self.client.send_query::<RealmReadOnlyDirectoryRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                RealmBuilderError,
            >, RealmMarker>(
                (name, to, &mut directory_contents),
                0x78a6d150a66e00dc,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Creates and routes a new storage capability to the provided targets.
    /// Optionally can connect the provided channel the the
    /// `fuchsia.sys2.StorageAdmin` protocol for this storage capability.
    pub fn r#add_storage(
        &self,
        mut name: &str,
        mut to: &[fidl_fuchsia_component_decl::Ref],
        mut storage_admin: Option<
            fidl::endpoints::ServerEnd<fidl_fuchsia_component::StorageAdminMarker>,
        >,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RealmAddStorageResult, fidl::Error> {
        let _response =
            self.client.send_query::<RealmAddStorageRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                RealmBuilderError,
            >, RealmMarker>(
                (name, to, storage_admin),
                0x4709da0c9576b7c1,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Load any packaged configuration for `name` before using values provided to
    /// the builder.
    ///
    /// Allows calling `SetConfigValue` to override packaged configuration.
    pub fn r#init_mutable_config_from_package(
        &self,
        mut name: &str,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RealmInitMutableConfigFromPackageResult, fidl::Error> {
        let _response = self.client.send_query::<
            RealmInitMutableConfigFromPackageRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, RealmBuilderError>,
            RealmMarker,
        >(
            (name,),
            0x36a30c9837c64216,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Use only values provided to the builder for `name`'s configuration.
    ///
    /// Allows calling `SetConfigValue` to provide configuration.
    pub fn r#init_mutable_config_to_empty(
        &self,
        mut name: &str,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RealmInitMutableConfigToEmptyResult, fidl::Error> {
        let _response = self.client.send_query::<
            RealmInitMutableConfigToEmptyRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, RealmBuilderError>,
            RealmMarker,
        >(
            (name,),
            0x772cb99e2e0dccc5,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Add a capability to the realm.
    pub fn r#add_capability(
        &self,
        mut capability: &fidl_fuchsia_component_decl::Capability,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RealmAddCapabilityResult, fidl::Error> {
        let _response =
            self.client.send_query::<RealmAddCapabilityRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                RealmBuilderError,
            >, RealmMarker>(
                (capability,),
                0x23a6499eb6080249,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Adds a collection to the realm.
    pub fn r#add_collection(
        &self,
        mut collection: &fidl_fuchsia_component_decl::Collection,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RealmAddCollectionResult, fidl::Error> {
        let _response =
            self.client.send_query::<RealmAddCollectionRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                RealmBuilderError,
            >, RealmMarker>(
                (collection,),
                0x56b75210a03a99b5,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Adds an environment to the realm.
    pub fn r#add_environment(
        &self,
        mut environment: &fidl_fuchsia_component_decl::Environment,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RealmAddEnvironmentResult, fidl::Error> {
        let _response =
            self.client.send_query::<RealmAddEnvironmentRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                RealmBuilderError,
            >, RealmMarker>(
                (environment,),
                0x1cd7caefa2cce0e9,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Sets the configuration value for a field specified by `key`.
    /// The component specified must have a config schema with this field.
    /// The value must conform to all constraints as defined by the schema.
    ///
    /// This method must be called after either `InitMutableConfigFromPackage` or
    /// `InitMutableConfigToEmpty`.
    ///
    /// Errors:
    /// - `NO_CONFIG_SCHEMA`: component does not have a config schema
    /// - `NO_SUCH_CONFIG_FIELD`: `key` could not be found in component's config schema
    /// - `CONFIG_VALUE_INVALID`: `value` does not meet config schema constraints
    pub fn r#set_config_value(
        &self,
        mut name: &str,
        mut key: &str,
        mut value: &fidl_fuchsia_component_decl::ConfigValueSpec,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RealmSetConfigValueResult, fidl::Error> {
        let _response =
            self.client.send_query::<RealmSetConfigValueRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                RealmBuilderError,
            >, RealmMarker>(
                (name, key, value),
                0x886450d291217f2,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }
}

#[cfg(target_os = "fuchsia")]
impl From<RealmSynchronousProxy> for zx::NullableHandle {
    fn from(value: RealmSynchronousProxy) -> Self {
        value.into_channel().into()
    }
}

#[cfg(target_os = "fuchsia")]
impl From<fidl::Channel> for RealmSynchronousProxy {
    fn from(value: fidl::Channel) -> Self {
        Self::new(value)
    }
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::FromClient for RealmSynchronousProxy {
    type Protocol = RealmMarker;

    fn from_client(value: fidl::endpoints::ClientEnd<RealmMarker>) -> Self {
        Self::new(value.into_channel())
    }
}

#[derive(Debug, Clone)]
pub struct RealmProxy {
    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl fidl::endpoints::Proxy for RealmProxy {
    type Protocol = RealmMarker;

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

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

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl RealmProxy {
    /// Create a new Proxy for fuchsia.component.test/Realm.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <RealmMarker as fidl::endpoints::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) -> RealmEventStream {
        RealmEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Adds a component to the realm.
    ///
    /// The `url` can be in one of the following formats:
    ///
    /// - an absolute component URL (such as,
    ///   "fuchsia-pkg://fuchsia.com/some-package#meta/some-component.cm")
    /// - a relative path component URL to a subpackaged component (like,
    ///   "some-subpackage#meta/subpackaged-component.cm"); or
    /// - a relative fragment-only URL (like, `#meta/other-component.cm`;
    ///   see https://fuchsia.dev/fuchsia-src/reference/components/url#relative-fragment-only)
    ///   indicating the path to a component manifest in the `pkg_dir` supplied
    ///   to `RealmBuilderFactory::Create*()`.
    ///
    /// The realm builder client typically passes a handle to its own `/pkg`
    /// directory, and bundles the `other-component` into the same package.
    ///
    /// Of the three URL types, _only_ component declarations added via the
    /// fragment-only URL can be modified, via
    /// `GetComponentDecl`/`ReplaceComponentDecl` because realm builder actually
    /// performs its own component resolution from the component's manifest and
    /// files bundled in the provided `pkg_dir` (typically from the package
    /// shared by the realm builder client component and the components added
    /// via fragment-only URL).
    ///
    /// Errors:
    /// - `CHILD_ALREADY_EXISTS`: this realm already contains a child with the
    ///   given name.
    /// - `INVALID_MANIFEST_EXTENSION`: `url` does not end with `.cm`
    /// - `DECL_NOT_FOUND`: The test package does not contain the component
    ///   declaration referenced by a fragment-only component URL.
    /// - `DECL_READ_ERROR`: Encountered an I/O error when attempting to read a
    ///   component declaration referenced by a fragment-only component URL from
    ///   the test package.
    /// - `BUILD_ALREADY_CALLED`: The `Builder.Build` function has been called
    ///   for this realm, and thus this `Realm` channel can no longer be used.
    pub fn r#add_child(
        &self,
        mut name: &str,
        mut url: &str,
        mut options: &ChildOptions,
    ) -> fidl::client::QueryResponseFut<
        RealmAddChildResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RealmProxyInterface::r#add_child(self, name, url, options)
    }

    /// Adds a component to this realm whose declaration is set to `decl`. When
    /// launched, the component will share the test package as its package
    /// directory, and may access any resources from it.
    ///
    /// Errors:
    /// - `CHILD_ALREADY_EXISTS`: this realm already contains a child with the
    ///   given name.
    /// - `INVALID_COMPONENT_DECL`: `decl` failed validation.
    /// - `BUILD_ALREADY_CALLED`: The `Builder.Build` function has been called
    ///   for this realm, and thus this `Realm` channel can no longer be used.
    pub fn r#add_child_from_decl(
        &self,
        mut name: &str,
        mut decl: &fidl_fuchsia_component_decl::Component,
        mut options: &ChildOptions,
    ) -> fidl::client::QueryResponseFut<
        RealmAddChildFromDeclResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RealmProxyInterface::r#add_child_from_decl(self, name, decl, options)
    }

    /// Adds a component to the realm whose implementation will be provided by
    /// the client. When this component should be started, the runner channel
    /// passed into `Build` will receive a start request for a component whose
    /// `ProgramDecl` contains the moniker from the root of the
    /// constructed realm for the child that is to be run under the `program`
    /// key `LOCAL_COMPONENT_NAME`.
    ///
    /// Errors:
    /// - `CHILD_ALREADY_EXISTS`: this realm already contains a child with the
    ///   given name.
    /// - `BUILD_ALREADY_CALLED`: The `Builder.Build` function has been called
    ///   for this realm, and thus this `Realm` channel can no longer be used.
    pub fn r#add_local_child(
        &self,
        mut name: &str,
        mut options: &ChildOptions,
    ) -> fidl::client::QueryResponseFut<
        RealmAddLocalChildResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RealmProxyInterface::r#add_local_child(self, name, options)
    }

    /// Adds a child realm which can be built with the client end of
    /// `child_realm`.
    ///
    /// Errors:
    /// - `CHILD_ALREADY_EXISTS`: this realm already contains a child with the
    ///   given name.
    /// - `BUILD_ALREADY_CALLED`: The `Builder.Build` function has been called
    ///   for this realm, and thus this `Realm` channel can no longer be used.
    pub fn r#add_child_realm(
        &self,
        mut name: &str,
        mut options: &ChildOptions,
        mut child_realm: fidl::endpoints::ServerEnd<RealmMarker>,
    ) -> fidl::client::QueryResponseFut<
        RealmAddChildRealmResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RealmProxyInterface::r#add_child_realm(self, name, options, child_realm)
    }

    /// Adds a child realm which can be built with the client end of
    /// `child_realm`, and whose contents are initialized from `relative_url`.
    /// `relative_url` must be a fragment-only URL.
    pub fn r#add_child_realm_from_relative_url(
        &self,
        mut name: &str,
        mut relative_url: &str,
        mut options: &ChildOptions,
        mut child_realm: fidl::endpoints::ServerEnd<RealmMarker>,
    ) -> fidl::client::QueryResponseFut<
        RealmAddChildRealmFromRelativeUrlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RealmProxyInterface::r#add_child_realm_from_relative_url(
            self,
            name,
            relative_url,
            options,
            child_realm,
        )
    }

    /// Adds a child realm which can be built with the client end of
    /// `child_realm`, and whose contents are initialized from `decl`.
    pub fn r#add_child_realm_from_decl(
        &self,
        mut name: &str,
        mut decl: &fidl_fuchsia_component_decl::Component,
        mut options: &ChildOptions,
        mut child_realm: fidl::endpoints::ServerEnd<RealmMarker>,
    ) -> fidl::client::QueryResponseFut<
        RealmAddChildRealmFromDeclResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RealmProxyInterface::r#add_child_realm_from_decl(self, name, decl, options, child_realm)
    }

    /// Returns the component decl for the given component. `name` must refer to
    /// a component that is one of the following:
    ///
    /// - A component with a local implementation
    /// - A legacy component
    /// - A component added with a fragment-only URL (typically, components
    ///   bundled in the same package as the realm builder client, sharing the
    ///   same `/pkg` directory, for example, `#meta/other-component.cm`; see
    ///   https://fuchsia.dev/fuchsia-src/reference/components/url#relative-fragment-only)
    /// - An automatically generated realm (ex: the root)
    ///
    /// Errors:
    /// - `NO_SUCH_CHILD`: This realm does not contain a child with the given
    ///   name.
    /// - `CHILD_DECL_NOT_VISIBLE`: The component decl cannot be fetched for
    ///   the referenced child, because the child was added to the realm using
    ///   a modern (not legacy) absolute URL or subpackaged component's relative
    ///   path URL.
    /// - `BUILD_ALREADY_CALLED`: The `Builder.Build` function has been called
    ///   for this realm, and thus this `Realm` channel can no longer be used.
    pub fn r#get_component_decl(
        &self,
        mut name: &str,
    ) -> fidl::client::QueryResponseFut<
        RealmGetComponentDeclResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RealmProxyInterface::r#get_component_decl(self, name)
    }

    /// Replaces the component decl for the given component. `name` must
    /// refer to a component that is one of the following:
    ///
    /// - A component with a local implementation
    /// - A legacy component
    /// - A component added with a fragment-only URL (typically, components
    ///   bundled in the same package as the realm builder client, sharing the
    ///   same `/pkg` directory, for example, `#meta/other-component.cm`; see
    ///   https://fuchsia.dev/fuchsia-src/reference/components/url#relative-fragment-only)
    /// - An automatically generated realm (ex: the root)
    ///
    /// Errors:
    /// - `NO_SUCH_CHILD`: This realm does not contain a child with the given
    ///   name.
    /// - `CHILD_ALREADY_EXISTS`: The component whose decl is being replaced has
    ///   had a child added to it through realm builder with the same name as an
    ///   element in `component_decl.children`.
    /// - `CHILD_DECL_NOT_VISIBLE`: The component decl cannot be manipulated for
    ///   the referenced child, because the child was added to the realm using
    ///   an absolute (not relative) and modern (not legacy) URL.
    /// - `INVALID_COMPONENT_DECL`: `component_decl` failed validation.
    /// - `BUILD_ALREADY_CALLED`: The `Builder.Build` function has been called
    ///   for this realm, and thus this `Realm` channel can no longer be used.
    pub fn r#replace_component_decl(
        &self,
        mut name: &str,
        mut component_decl: &fidl_fuchsia_component_decl::Component,
    ) -> fidl::client::QueryResponseFut<
        RealmReplaceComponentDeclResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RealmProxyInterface::r#replace_component_decl(self, name, component_decl)
    }

    /// Returns the component decl for this realm.
    ///
    /// Errors:
    /// - `BUILD_ALREADY_CALLED`: The `Builder.Build` function has been called
    ///   for this realm, and thus this `Realm` channel can no longer be used.
    pub fn r#get_realm_decl(
        &self,
    ) -> fidl::client::QueryResponseFut<
        RealmGetRealmDeclResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RealmProxyInterface::r#get_realm_decl(self)
    }

    /// Replaces the component decl for this realm.
    ///
    /// Errors:
    /// - `INVALID_COMPONENT_DECL`: `component_decl` failed validation.
    /// - `BUILD_ALREADY_CALLED`: The `Builder.Build` function has been called
    ///   for this realm, and thus this `Realm` channel can no longer be used.
    pub fn r#replace_realm_decl(
        &self,
        mut component_decl: &fidl_fuchsia_component_decl::Component,
    ) -> fidl::client::QueryResponseFut<
        RealmReplaceRealmDeclResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RealmProxyInterface::r#replace_realm_decl(self, component_decl)
    }

    /// Inform the realm builder server that this realm is using a nested component manager. It's
    /// expected that the client library has already replaced the realm's declaration with a
    /// passthrough component manager declaration, with the exception of the root url.
    /// This method will arrange for [Builder.Build] to install the realm's generated url as the
    /// root url in this component manager.
    pub fn r#use_nested_component_manager(
        &self,
        mut component_manager_relative_url: &str,
    ) -> fidl::client::QueryResponseFut<
        RealmUseNestedComponentManagerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RealmProxyInterface::r#use_nested_component_manager(self, component_manager_relative_url)
    }

    /// Identical to `AddRouteFromDictionary`, except it does not accept `from_dictionary` which
    /// it always sets to ".".
    pub fn r#add_route(
        &self,
        mut capabilities: &[Capability],
        mut from: &fidl_fuchsia_component_decl::Ref,
        mut to: &[fidl_fuchsia_component_decl::Ref],
    ) -> fidl::client::QueryResponseFut<
        RealmAddRouteResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RealmProxyInterface::r#add_route(self, capabilities, from, to)
    }

    /// Mutates component manifests in the realm such that every component in
    /// `to` will have a valid capability route for each item in `capabilities`
    /// provided by `from`.
    ///
    /// Errors:
    /// - `NO_SUCH_SOURCE`: `from` references a non-existent child.
    /// - `NO_SUCH_TARGET`: `to` references a non-existent child.
    /// - `CAPABILITIES_EMPTY`: `capabilities` is empty.
    /// - `TARGETS_EMPTY`: `to` is empty.
    /// - `SOURCE_AND_TARGET_MATCH`: `from` is equal to one of the elements in
    ///   `to`.
    /// - `INVALID_COMPONENT_DECL`: The requested route caused one of the
    ///   involved manifests to fail validation.
    /// - `BUILD_ALREADY_CALLED`: The `Builder.Build` function has been called
    ///   for this realm, and thus this `Realm` channel can no longer be used.
    pub fn r#add_route_from_dictionary(
        &self,
        mut capabilities: &[Capability],
        mut from: &fidl_fuchsia_component_decl::Ref,
        mut from_dictionary: &str,
        mut to: &[fidl_fuchsia_component_decl::Ref],
    ) -> fidl::client::QueryResponseFut<
        RealmAddRouteFromDictionaryResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RealmProxyInterface::r#add_route_from_dictionary(
            self,
            capabilities,
            from,
            from_dictionary,
            to,
        )
    }

    /// Offers a directory capability to a component in this realm. The
    /// directory will be read-only (i.e. have `r*` rights), and will have the
    /// contents described in `directory_contents`.
    ///
    /// Errors:
    /// - `NO_SUCH_TARGET`: `offer-to` references a non-existent child.
    /// - `BUILD_ALREADY_CALLED`: The `Builder.Build` function has been called
    ///   for this realm, and thus this `Realm` channel can no longer be used.
    pub fn r#read_only_directory(
        &self,
        mut name: &str,
        mut to: &[fidl_fuchsia_component_decl::Ref],
        mut directory_contents: DirectoryContents,
    ) -> fidl::client::QueryResponseFut<
        RealmReadOnlyDirectoryResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RealmProxyInterface::r#read_only_directory(self, name, to, directory_contents)
    }

    /// Creates and routes a new storage capability to the provided targets.
    /// Optionally can connect the provided channel the the
    /// `fuchsia.sys2.StorageAdmin` protocol for this storage capability.
    pub fn r#add_storage(
        &self,
        mut name: &str,
        mut to: &[fidl_fuchsia_component_decl::Ref],
        mut storage_admin: Option<
            fidl::endpoints::ServerEnd<fidl_fuchsia_component::StorageAdminMarker>,
        >,
    ) -> fidl::client::QueryResponseFut<
        RealmAddStorageResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RealmProxyInterface::r#add_storage(self, name, to, storage_admin)
    }

    /// Load any packaged configuration for `name` before using values provided to
    /// the builder.
    ///
    /// Allows calling `SetConfigValue` to override packaged configuration.
    pub fn r#init_mutable_config_from_package(
        &self,
        mut name: &str,
    ) -> fidl::client::QueryResponseFut<
        RealmInitMutableConfigFromPackageResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RealmProxyInterface::r#init_mutable_config_from_package(self, name)
    }

    /// Use only values provided to the builder for `name`'s configuration.
    ///
    /// Allows calling `SetConfigValue` to provide configuration.
    pub fn r#init_mutable_config_to_empty(
        &self,
        mut name: &str,
    ) -> fidl::client::QueryResponseFut<
        RealmInitMutableConfigToEmptyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RealmProxyInterface::r#init_mutable_config_to_empty(self, name)
    }

    /// Add a capability to the realm.
    pub fn r#add_capability(
        &self,
        mut capability: &fidl_fuchsia_component_decl::Capability,
    ) -> fidl::client::QueryResponseFut<
        RealmAddCapabilityResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RealmProxyInterface::r#add_capability(self, capability)
    }

    /// Adds a collection to the realm.
    pub fn r#add_collection(
        &self,
        mut collection: &fidl_fuchsia_component_decl::Collection,
    ) -> fidl::client::QueryResponseFut<
        RealmAddCollectionResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RealmProxyInterface::r#add_collection(self, collection)
    }

    /// Adds an environment to the realm.
    pub fn r#add_environment(
        &self,
        mut environment: &fidl_fuchsia_component_decl::Environment,
    ) -> fidl::client::QueryResponseFut<
        RealmAddEnvironmentResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RealmProxyInterface::r#add_environment(self, environment)
    }

    /// Sets the configuration value for a field specified by `key`.
    /// The component specified must have a config schema with this field.
    /// The value must conform to all constraints as defined by the schema.
    ///
    /// This method must be called after either `InitMutableConfigFromPackage` or
    /// `InitMutableConfigToEmpty`.
    ///
    /// Errors:
    /// - `NO_CONFIG_SCHEMA`: component does not have a config schema
    /// - `NO_SUCH_CONFIG_FIELD`: `key` could not be found in component's config schema
    /// - `CONFIG_VALUE_INVALID`: `value` does not meet config schema constraints
    pub fn r#set_config_value(
        &self,
        mut name: &str,
        mut key: &str,
        mut value: &fidl_fuchsia_component_decl::ConfigValueSpec,
    ) -> fidl::client::QueryResponseFut<
        RealmSetConfigValueResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RealmProxyInterface::r#set_config_value(self, name, key, value)
    }
}

impl RealmProxyInterface for RealmProxy {
    type AddChildResponseFut = fidl::client::QueryResponseFut<
        RealmAddChildResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#add_child(
        &self,
        mut name: &str,
        mut url: &str,
        mut options: &ChildOptions,
    ) -> Self::AddChildResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RealmAddChildResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, RealmBuilderError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3f6c07627303d801,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<RealmAddChildRequest, RealmAddChildResult>(
            (name, url, options),
            0x3f6c07627303d801,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type AddChildFromDeclResponseFut = fidl::client::QueryResponseFut<
        RealmAddChildFromDeclResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#add_child_from_decl(
        &self,
        mut name: &str,
        mut decl: &fidl_fuchsia_component_decl::Component,
        mut options: &ChildOptions,
    ) -> Self::AddChildFromDeclResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RealmAddChildFromDeclResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, RealmBuilderError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3950ad500258156d,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<RealmAddChildFromDeclRequest, RealmAddChildFromDeclResult>(
                (name, decl, options),
                0x3950ad500258156d,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type AddLocalChildResponseFut = fidl::client::QueryResponseFut<
        RealmAddLocalChildResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#add_local_child(
        &self,
        mut name: &str,
        mut options: &ChildOptions,
    ) -> Self::AddLocalChildResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RealmAddLocalChildResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, RealmBuilderError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3249817bae10abbb,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<RealmAddLocalChildRequest, RealmAddLocalChildResult>(
            (name, options),
            0x3249817bae10abbb,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type AddChildRealmResponseFut = fidl::client::QueryResponseFut<
        RealmAddChildRealmResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#add_child_realm(
        &self,
        mut name: &str,
        mut options: &ChildOptions,
        mut child_realm: fidl::endpoints::ServerEnd<RealmMarker>,
    ) -> Self::AddChildRealmResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RealmAddChildRealmResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, RealmBuilderError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3fdf98db373b9458,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<RealmAddChildRealmRequest, RealmAddChildRealmResult>(
            (name, options, child_realm),
            0x3fdf98db373b9458,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type AddChildRealmFromRelativeUrlResponseFut = fidl::client::QueryResponseFut<
        RealmAddChildRealmFromRelativeUrlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#add_child_realm_from_relative_url(
        &self,
        mut name: &str,
        mut relative_url: &str,
        mut options: &ChildOptions,
        mut child_realm: fidl::endpoints::ServerEnd<RealmMarker>,
    ) -> Self::AddChildRealmFromRelativeUrlResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RealmAddChildRealmFromRelativeUrlResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, RealmBuilderError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x44c34c8dcbe06abb,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            RealmAddChildRealmFromRelativeUrlRequest,
            RealmAddChildRealmFromRelativeUrlResult,
        >(
            (name, relative_url, options, child_realm,),
            0x44c34c8dcbe06abb,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type AddChildRealmFromDeclResponseFut = fidl::client::QueryResponseFut<
        RealmAddChildRealmFromDeclResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#add_child_realm_from_decl(
        &self,
        mut name: &str,
        mut decl: &fidl_fuchsia_component_decl::Component,
        mut options: &ChildOptions,
        mut child_realm: fidl::endpoints::ServerEnd<RealmMarker>,
    ) -> Self::AddChildRealmFromDeclResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RealmAddChildRealmFromDeclResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, RealmBuilderError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x142e5c326732862e,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            RealmAddChildRealmFromDeclRequest,
            RealmAddChildRealmFromDeclResult,
        >(
            (name, decl, options, child_realm,),
            0x142e5c326732862e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetComponentDeclResponseFut = fidl::client::QueryResponseFut<
        RealmGetComponentDeclResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_component_decl(&self, mut name: &str) -> Self::GetComponentDeclResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RealmGetComponentDeclResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<RealmGetComponentDeclResponse, RealmBuilderError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x320832af6a4cbac6,
            >(_buf?)?;
            Ok(_response.map(|x| x.component_decl))
        }
        self.client
            .send_query_and_decode::<RealmGetComponentDeclRequest, RealmGetComponentDeclResult>(
                (name,),
                0x320832af6a4cbac6,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type ReplaceComponentDeclResponseFut = fidl::client::QueryResponseFut<
        RealmReplaceComponentDeclResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#replace_component_decl(
        &self,
        mut name: &str,
        mut component_decl: &fidl_fuchsia_component_decl::Component,
    ) -> Self::ReplaceComponentDeclResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RealmReplaceComponentDeclResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, RealmBuilderError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x59cecf31b314cd5f,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            RealmReplaceComponentDeclRequest,
            RealmReplaceComponentDeclResult,
        >(
            (name, component_decl,),
            0x59cecf31b314cd5f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetRealmDeclResponseFut = fidl::client::QueryResponseFut<
        RealmGetRealmDeclResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_realm_decl(&self) -> Self::GetRealmDeclResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RealmGetRealmDeclResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<RealmGetRealmDeclResponse, RealmBuilderError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x46fa05b17bd64269,
            >(_buf?)?;
            Ok(_response.map(|x| x.component_decl))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, RealmGetRealmDeclResult>(
            (),
            0x46fa05b17bd64269,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ReplaceRealmDeclResponseFut = fidl::client::QueryResponseFut<
        RealmReplaceRealmDeclResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#replace_realm_decl(
        &self,
        mut component_decl: &fidl_fuchsia_component_decl::Component,
    ) -> Self::ReplaceRealmDeclResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RealmReplaceRealmDeclResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, RealmBuilderError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x48fcba4ac1338da9,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<RealmReplaceRealmDeclRequest, RealmReplaceRealmDeclResult>(
                (component_decl,),
                0x48fcba4ac1338da9,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type UseNestedComponentManagerResponseFut = fidl::client::QueryResponseFut<
        RealmUseNestedComponentManagerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#use_nested_component_manager(
        &self,
        mut component_manager_relative_url: &str,
    ) -> Self::UseNestedComponentManagerResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RealmUseNestedComponentManagerResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, RealmBuilderError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x64bd27482f3dcc,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            RealmUseNestedComponentManagerRequest,
            RealmUseNestedComponentManagerResult,
        >(
            (component_manager_relative_url,),
            0x64bd27482f3dcc,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type AddRouteResponseFut = fidl::client::QueryResponseFut<
        RealmAddRouteResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#add_route(
        &self,
        mut capabilities: &[Capability],
        mut from: &fidl_fuchsia_component_decl::Ref,
        mut to: &[fidl_fuchsia_component_decl::Ref],
    ) -> Self::AddRouteResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RealmAddRouteResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, RealmBuilderError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x9d523295be53a0a,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<RealmAddRouteRequest, RealmAddRouteResult>(
            (capabilities, from, to),
            0x9d523295be53a0a,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type AddRouteFromDictionaryResponseFut = fidl::client::QueryResponseFut<
        RealmAddRouteFromDictionaryResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#add_route_from_dictionary(
        &self,
        mut capabilities: &[Capability],
        mut from: &fidl_fuchsia_component_decl::Ref,
        mut from_dictionary: &str,
        mut to: &[fidl_fuchsia_component_decl::Ref],
    ) -> Self::AddRouteFromDictionaryResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RealmAddRouteFromDictionaryResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, RealmBuilderError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x21fac42c3e1d14d2,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            RealmAddRouteFromDictionaryRequest,
            RealmAddRouteFromDictionaryResult,
        >(
            (capabilities, from, from_dictionary, to,),
            0x21fac42c3e1d14d2,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ReadOnlyDirectoryResponseFut = fidl::client::QueryResponseFut<
        RealmReadOnlyDirectoryResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#read_only_directory(
        &self,
        mut name: &str,
        mut to: &[fidl_fuchsia_component_decl::Ref],
        mut directory_contents: DirectoryContents,
    ) -> Self::ReadOnlyDirectoryResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RealmReadOnlyDirectoryResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, RealmBuilderError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x78a6d150a66e00dc,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<RealmReadOnlyDirectoryRequest, RealmReadOnlyDirectoryResult>(
                (name, to, &mut directory_contents),
                0x78a6d150a66e00dc,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type AddStorageResponseFut = fidl::client::QueryResponseFut<
        RealmAddStorageResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#add_storage(
        &self,
        mut name: &str,
        mut to: &[fidl_fuchsia_component_decl::Ref],
        mut storage_admin: Option<
            fidl::endpoints::ServerEnd<fidl_fuchsia_component::StorageAdminMarker>,
        >,
    ) -> Self::AddStorageResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RealmAddStorageResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, RealmBuilderError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4709da0c9576b7c1,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<RealmAddStorageRequest, RealmAddStorageResult>(
            (name, to, storage_admin),
            0x4709da0c9576b7c1,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type InitMutableConfigFromPackageResponseFut = fidl::client::QueryResponseFut<
        RealmInitMutableConfigFromPackageResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#init_mutable_config_from_package(
        &self,
        mut name: &str,
    ) -> Self::InitMutableConfigFromPackageResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RealmInitMutableConfigFromPackageResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, RealmBuilderError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x36a30c9837c64216,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            RealmInitMutableConfigFromPackageRequest,
            RealmInitMutableConfigFromPackageResult,
        >(
            (name,),
            0x36a30c9837c64216,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type InitMutableConfigToEmptyResponseFut = fidl::client::QueryResponseFut<
        RealmInitMutableConfigToEmptyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#init_mutable_config_to_empty(
        &self,
        mut name: &str,
    ) -> Self::InitMutableConfigToEmptyResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RealmInitMutableConfigToEmptyResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, RealmBuilderError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x772cb99e2e0dccc5,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            RealmInitMutableConfigToEmptyRequest,
            RealmInitMutableConfigToEmptyResult,
        >(
            (name,),
            0x772cb99e2e0dccc5,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type AddCapabilityResponseFut = fidl::client::QueryResponseFut<
        RealmAddCapabilityResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#add_capability(
        &self,
        mut capability: &fidl_fuchsia_component_decl::Capability,
    ) -> Self::AddCapabilityResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RealmAddCapabilityResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, RealmBuilderError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x23a6499eb6080249,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<RealmAddCapabilityRequest, RealmAddCapabilityResult>(
            (capability,),
            0x23a6499eb6080249,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type AddCollectionResponseFut = fidl::client::QueryResponseFut<
        RealmAddCollectionResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#add_collection(
        &self,
        mut collection: &fidl_fuchsia_component_decl::Collection,
    ) -> Self::AddCollectionResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RealmAddCollectionResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, RealmBuilderError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x56b75210a03a99b5,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<RealmAddCollectionRequest, RealmAddCollectionResult>(
            (collection,),
            0x56b75210a03a99b5,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type AddEnvironmentResponseFut = fidl::client::QueryResponseFut<
        RealmAddEnvironmentResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#add_environment(
        &self,
        mut environment: &fidl_fuchsia_component_decl::Environment,
    ) -> Self::AddEnvironmentResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RealmAddEnvironmentResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, RealmBuilderError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1cd7caefa2cce0e9,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<RealmAddEnvironmentRequest, RealmAddEnvironmentResult>(
            (environment,),
            0x1cd7caefa2cce0e9,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetConfigValueResponseFut = fidl::client::QueryResponseFut<
        RealmSetConfigValueResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_config_value(
        &self,
        mut name: &str,
        mut key: &str,
        mut value: &fidl_fuchsia_component_decl::ConfigValueSpec,
    ) -> Self::SetConfigValueResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RealmSetConfigValueResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, RealmBuilderError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x886450d291217f2,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<RealmSetConfigValueRequest, RealmSetConfigValueResult>(
            (name, key, value),
            0x886450d291217f2,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

pub struct RealmEventStream {
    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

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

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

impl futures::Stream for RealmEventStream {
    type Item = Result<RealmEvent, 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(RealmEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

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

impl RealmEvent {
    /// Decodes a message buffer as a [`RealmEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<RealmEvent, 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: <RealmMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.component.test/Realm.
pub struct RealmRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for RealmRequestStream {
    type Protocol = RealmMarker;
    type ControlHandle = RealmControlHandle;

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

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

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

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

impl futures::Stream for RealmRequestStream {
    type Item = Result<RealmRequest, 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 RealmRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |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(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(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 {
                    0x3f6c07627303d801 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RealmAddChildRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RealmAddChildRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RealmControlHandle { inner: this.inner.clone() };
                        Ok(RealmRequest::AddChild {
                            name: req.name,
                            url: req.url,
                            options: req.options,

                            responder: RealmAddChildResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3950ad500258156d => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RealmAddChildFromDeclRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RealmAddChildFromDeclRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RealmControlHandle { inner: this.inner.clone() };
                        Ok(RealmRequest::AddChildFromDecl {
                            name: req.name,
                            decl: req.decl,
                            options: req.options,

                            responder: RealmAddChildFromDeclResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3249817bae10abbb => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RealmAddLocalChildRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RealmAddLocalChildRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RealmControlHandle { inner: this.inner.clone() };
                        Ok(RealmRequest::AddLocalChild {
                            name: req.name,
                            options: req.options,

                            responder: RealmAddLocalChildResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3fdf98db373b9458 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RealmAddChildRealmRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RealmAddChildRealmRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RealmControlHandle { inner: this.inner.clone() };
                        Ok(RealmRequest::AddChildRealm {
                            name: req.name,
                            options: req.options,
                            child_realm: req.child_realm,

                            responder: RealmAddChildRealmResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x44c34c8dcbe06abb => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RealmAddChildRealmFromRelativeUrlRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RealmAddChildRealmFromRelativeUrlRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RealmControlHandle { inner: this.inner.clone() };
                        Ok(RealmRequest::AddChildRealmFromRelativeUrl {
                            name: req.name,
                            relative_url: req.relative_url,
                            options: req.options,
                            child_realm: req.child_realm,

                            responder: RealmAddChildRealmFromRelativeUrlResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x142e5c326732862e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RealmAddChildRealmFromDeclRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RealmAddChildRealmFromDeclRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RealmControlHandle { inner: this.inner.clone() };
                        Ok(RealmRequest::AddChildRealmFromDecl {
                            name: req.name,
                            decl: req.decl,
                            options: req.options,
                            child_realm: req.child_realm,

                            responder: RealmAddChildRealmFromDeclResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x320832af6a4cbac6 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RealmGetComponentDeclRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RealmGetComponentDeclRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RealmControlHandle { inner: this.inner.clone() };
                        Ok(RealmRequest::GetComponentDecl {
                            name: req.name,

                            responder: RealmGetComponentDeclResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x59cecf31b314cd5f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RealmReplaceComponentDeclRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RealmReplaceComponentDeclRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RealmControlHandle { inner: this.inner.clone() };
                        Ok(RealmRequest::ReplaceComponentDecl {
                            name: req.name,
                            component_decl: req.component_decl,

                            responder: RealmReplaceComponentDeclResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x46fa05b17bd64269 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RealmControlHandle { inner: this.inner.clone() };
                        Ok(RealmRequest::GetRealmDecl {
                            responder: RealmGetRealmDeclResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x48fcba4ac1338da9 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RealmReplaceRealmDeclRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RealmReplaceRealmDeclRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RealmControlHandle { inner: this.inner.clone() };
                        Ok(RealmRequest::ReplaceRealmDecl {
                            component_decl: req.component_decl,

                            responder: RealmReplaceRealmDeclResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x64bd27482f3dcc => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RealmUseNestedComponentManagerRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RealmUseNestedComponentManagerRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RealmControlHandle { inner: this.inner.clone() };
                        Ok(RealmRequest::UseNestedComponentManager {
                            component_manager_relative_url: req.component_manager_relative_url,

                            responder: RealmUseNestedComponentManagerResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x9d523295be53a0a => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RealmAddRouteRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RealmAddRouteRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RealmControlHandle { inner: this.inner.clone() };
                        Ok(RealmRequest::AddRoute {
                            capabilities: req.capabilities,
                            from: req.from,
                            to: req.to,

                            responder: RealmAddRouteResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x21fac42c3e1d14d2 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RealmAddRouteFromDictionaryRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RealmAddRouteFromDictionaryRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RealmControlHandle { inner: this.inner.clone() };
                        Ok(RealmRequest::AddRouteFromDictionary {
                            capabilities: req.capabilities,
                            from: req.from,
                            from_dictionary: req.from_dictionary,
                            to: req.to,

                            responder: RealmAddRouteFromDictionaryResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x78a6d150a66e00dc => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RealmReadOnlyDirectoryRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RealmReadOnlyDirectoryRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RealmControlHandle { inner: this.inner.clone() };
                        Ok(RealmRequest::ReadOnlyDirectory {
                            name: req.name,
                            to: req.to,
                            directory_contents: req.directory_contents,

                            responder: RealmReadOnlyDirectoryResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4709da0c9576b7c1 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RealmAddStorageRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RealmAddStorageRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RealmControlHandle { inner: this.inner.clone() };
                        Ok(RealmRequest::AddStorage {
                            name: req.name,
                            to: req.to,
                            storage_admin: req.storage_admin,

                            responder: RealmAddStorageResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x36a30c9837c64216 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RealmInitMutableConfigFromPackageRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RealmInitMutableConfigFromPackageRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RealmControlHandle { inner: this.inner.clone() };
                        Ok(RealmRequest::InitMutableConfigFromPackage {
                            name: req.name,

                            responder: RealmInitMutableConfigFromPackageResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x772cb99e2e0dccc5 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RealmInitMutableConfigToEmptyRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RealmInitMutableConfigToEmptyRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RealmControlHandle { inner: this.inner.clone() };
                        Ok(RealmRequest::InitMutableConfigToEmpty {
                            name: req.name,

                            responder: RealmInitMutableConfigToEmptyResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x23a6499eb6080249 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RealmAddCapabilityRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RealmAddCapabilityRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RealmControlHandle { inner: this.inner.clone() };
                        Ok(RealmRequest::AddCapability {
                            capability: req.capability,

                            responder: RealmAddCapabilityResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x56b75210a03a99b5 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RealmAddCollectionRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RealmAddCollectionRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RealmControlHandle { inner: this.inner.clone() };
                        Ok(RealmRequest::AddCollection {
                            collection: req.collection,

                            responder: RealmAddCollectionResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1cd7caefa2cce0e9 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RealmAddEnvironmentRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RealmAddEnvironmentRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RealmControlHandle { inner: this.inner.clone() };
                        Ok(RealmRequest::AddEnvironment {
                            environment: req.environment,

                            responder: RealmAddEnvironmentResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x886450d291217f2 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RealmSetConfigValueRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RealmSetConfigValueRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RealmControlHandle { inner: this.inner.clone() };
                        Ok(RealmRequest::SetConfigValue {
                            name: req.name,
                            key: req.key,
                            value: req.value,

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

#[derive(Debug)]
pub enum RealmRequest {
    /// Adds a component to the realm.
    ///
    /// The `url` can be in one of the following formats:
    ///
    /// - an absolute component URL (such as,
    ///   "fuchsia-pkg://fuchsia.com/some-package#meta/some-component.cm")
    /// - a relative path component URL to a subpackaged component (like,
    ///   "some-subpackage#meta/subpackaged-component.cm"); or
    /// - a relative fragment-only URL (like, `#meta/other-component.cm`;
    ///   see https://fuchsia.dev/fuchsia-src/reference/components/url#relative-fragment-only)
    ///   indicating the path to a component manifest in the `pkg_dir` supplied
    ///   to `RealmBuilderFactory::Create*()`.
    ///
    /// The realm builder client typically passes a handle to its own `/pkg`
    /// directory, and bundles the `other-component` into the same package.
    ///
    /// Of the three URL types, _only_ component declarations added via the
    /// fragment-only URL can be modified, via
    /// `GetComponentDecl`/`ReplaceComponentDecl` because realm builder actually
    /// performs its own component resolution from the component's manifest and
    /// files bundled in the provided `pkg_dir` (typically from the package
    /// shared by the realm builder client component and the components added
    /// via fragment-only URL).
    ///
    /// Errors:
    /// - `CHILD_ALREADY_EXISTS`: this realm already contains a child with the
    ///   given name.
    /// - `INVALID_MANIFEST_EXTENSION`: `url` does not end with `.cm`
    /// - `DECL_NOT_FOUND`: The test package does not contain the component
    ///   declaration referenced by a fragment-only component URL.
    /// - `DECL_READ_ERROR`: Encountered an I/O error when attempting to read a
    ///   component declaration referenced by a fragment-only component URL from
    ///   the test package.
    /// - `BUILD_ALREADY_CALLED`: The `Builder.Build` function has been called
    ///   for this realm, and thus this `Realm` channel can no longer be used.
    AddChild { name: String, url: String, options: ChildOptions, responder: RealmAddChildResponder },
    /// Adds a component to this realm whose declaration is set to `decl`. When
    /// launched, the component will share the test package as its package
    /// directory, and may access any resources from it.
    ///
    /// Errors:
    /// - `CHILD_ALREADY_EXISTS`: this realm already contains a child with the
    ///   given name.
    /// - `INVALID_COMPONENT_DECL`: `decl` failed validation.
    /// - `BUILD_ALREADY_CALLED`: The `Builder.Build` function has been called
    ///   for this realm, and thus this `Realm` channel can no longer be used.
    AddChildFromDecl {
        name: String,
        decl: fidl_fuchsia_component_decl::Component,
        options: ChildOptions,
        responder: RealmAddChildFromDeclResponder,
    },
    /// Adds a component to the realm whose implementation will be provided by
    /// the client. When this component should be started, the runner channel
    /// passed into `Build` will receive a start request for a component whose
    /// `ProgramDecl` contains the moniker from the root of the
    /// constructed realm for the child that is to be run under the `program`
    /// key `LOCAL_COMPONENT_NAME`.
    ///
    /// Errors:
    /// - `CHILD_ALREADY_EXISTS`: this realm already contains a child with the
    ///   given name.
    /// - `BUILD_ALREADY_CALLED`: The `Builder.Build` function has been called
    ///   for this realm, and thus this `Realm` channel can no longer be used.
    AddLocalChild { name: String, options: ChildOptions, responder: RealmAddLocalChildResponder },
    /// Adds a child realm which can be built with the client end of
    /// `child_realm`.
    ///
    /// Errors:
    /// - `CHILD_ALREADY_EXISTS`: this realm already contains a child with the
    ///   given name.
    /// - `BUILD_ALREADY_CALLED`: The `Builder.Build` function has been called
    ///   for this realm, and thus this `Realm` channel can no longer be used.
    AddChildRealm {
        name: String,
        options: ChildOptions,
        child_realm: fidl::endpoints::ServerEnd<RealmMarker>,
        responder: RealmAddChildRealmResponder,
    },
    /// Adds a child realm which can be built with the client end of
    /// `child_realm`, and whose contents are initialized from `relative_url`.
    /// `relative_url` must be a fragment-only URL.
    AddChildRealmFromRelativeUrl {
        name: String,
        relative_url: String,
        options: ChildOptions,
        child_realm: fidl::endpoints::ServerEnd<RealmMarker>,
        responder: RealmAddChildRealmFromRelativeUrlResponder,
    },
    /// Adds a child realm which can be built with the client end of
    /// `child_realm`, and whose contents are initialized from `decl`.
    AddChildRealmFromDecl {
        name: String,
        decl: fidl_fuchsia_component_decl::Component,
        options: ChildOptions,
        child_realm: fidl::endpoints::ServerEnd<RealmMarker>,
        responder: RealmAddChildRealmFromDeclResponder,
    },
    /// Returns the component decl for the given component. `name` must refer to
    /// a component that is one of the following:
    ///
    /// - A component with a local implementation
    /// - A legacy component
    /// - A component added with a fragment-only URL (typically, components
    ///   bundled in the same package as the realm builder client, sharing the
    ///   same `/pkg` directory, for example, `#meta/other-component.cm`; see
    ///   https://fuchsia.dev/fuchsia-src/reference/components/url#relative-fragment-only)
    /// - An automatically generated realm (ex: the root)
    ///
    /// Errors:
    /// - `NO_SUCH_CHILD`: This realm does not contain a child with the given
    ///   name.
    /// - `CHILD_DECL_NOT_VISIBLE`: The component decl cannot be fetched for
    ///   the referenced child, because the child was added to the realm using
    ///   a modern (not legacy) absolute URL or subpackaged component's relative
    ///   path URL.
    /// - `BUILD_ALREADY_CALLED`: The `Builder.Build` function has been called
    ///   for this realm, and thus this `Realm` channel can no longer be used.
    GetComponentDecl { name: String, responder: RealmGetComponentDeclResponder },
    /// Replaces the component decl for the given component. `name` must
    /// refer to a component that is one of the following:
    ///
    /// - A component with a local implementation
    /// - A legacy component
    /// - A component added with a fragment-only URL (typically, components
    ///   bundled in the same package as the realm builder client, sharing the
    ///   same `/pkg` directory, for example, `#meta/other-component.cm`; see
    ///   https://fuchsia.dev/fuchsia-src/reference/components/url#relative-fragment-only)
    /// - An automatically generated realm (ex: the root)
    ///
    /// Errors:
    /// - `NO_SUCH_CHILD`: This realm does not contain a child with the given
    ///   name.
    /// - `CHILD_ALREADY_EXISTS`: The component whose decl is being replaced has
    ///   had a child added to it through realm builder with the same name as an
    ///   element in `component_decl.children`.
    /// - `CHILD_DECL_NOT_VISIBLE`: The component decl cannot be manipulated for
    ///   the referenced child, because the child was added to the realm using
    ///   an absolute (not relative) and modern (not legacy) URL.
    /// - `INVALID_COMPONENT_DECL`: `component_decl` failed validation.
    /// - `BUILD_ALREADY_CALLED`: The `Builder.Build` function has been called
    ///   for this realm, and thus this `Realm` channel can no longer be used.
    ReplaceComponentDecl {
        name: String,
        component_decl: fidl_fuchsia_component_decl::Component,
        responder: RealmReplaceComponentDeclResponder,
    },
    /// Returns the component decl for this realm.
    ///
    /// Errors:
    /// - `BUILD_ALREADY_CALLED`: The `Builder.Build` function has been called
    ///   for this realm, and thus this `Realm` channel can no longer be used.
    GetRealmDecl { responder: RealmGetRealmDeclResponder },
    /// Replaces the component decl for this realm.
    ///
    /// Errors:
    /// - `INVALID_COMPONENT_DECL`: `component_decl` failed validation.
    /// - `BUILD_ALREADY_CALLED`: The `Builder.Build` function has been called
    ///   for this realm, and thus this `Realm` channel can no longer be used.
    ReplaceRealmDecl {
        component_decl: fidl_fuchsia_component_decl::Component,
        responder: RealmReplaceRealmDeclResponder,
    },
    /// Inform the realm builder server that this realm is using a nested component manager. It's
    /// expected that the client library has already replaced the realm's declaration with a
    /// passthrough component manager declaration, with the exception of the root url.
    /// This method will arrange for [Builder.Build] to install the realm's generated url as the
    /// root url in this component manager.
    UseNestedComponentManager {
        component_manager_relative_url: String,
        responder: RealmUseNestedComponentManagerResponder,
    },
    /// Identical to `AddRouteFromDictionary`, except it does not accept `from_dictionary` which
    /// it always sets to ".".
    AddRoute {
        capabilities: Vec<Capability>,
        from: fidl_fuchsia_component_decl::Ref,
        to: Vec<fidl_fuchsia_component_decl::Ref>,
        responder: RealmAddRouteResponder,
    },
    /// Mutates component manifests in the realm such that every component in
    /// `to` will have a valid capability route for each item in `capabilities`
    /// provided by `from`.
    ///
    /// Errors:
    /// - `NO_SUCH_SOURCE`: `from` references a non-existent child.
    /// - `NO_SUCH_TARGET`: `to` references a non-existent child.
    /// - `CAPABILITIES_EMPTY`: `capabilities` is empty.
    /// - `TARGETS_EMPTY`: `to` is empty.
    /// - `SOURCE_AND_TARGET_MATCH`: `from` is equal to one of the elements in
    ///   `to`.
    /// - `INVALID_COMPONENT_DECL`: The requested route caused one of the
    ///   involved manifests to fail validation.
    /// - `BUILD_ALREADY_CALLED`: The `Builder.Build` function has been called
    ///   for this realm, and thus this `Realm` channel can no longer be used.
    AddRouteFromDictionary {
        capabilities: Vec<Capability>,
        from: fidl_fuchsia_component_decl::Ref,
        from_dictionary: String,
        to: Vec<fidl_fuchsia_component_decl::Ref>,
        responder: RealmAddRouteFromDictionaryResponder,
    },
    /// Offers a directory capability to a component in this realm. The
    /// directory will be read-only (i.e. have `r*` rights), and will have the
    /// contents described in `directory_contents`.
    ///
    /// Errors:
    /// - `NO_SUCH_TARGET`: `offer-to` references a non-existent child.
    /// - `BUILD_ALREADY_CALLED`: The `Builder.Build` function has been called
    ///   for this realm, and thus this `Realm` channel can no longer be used.
    ReadOnlyDirectory {
        name: String,
        to: Vec<fidl_fuchsia_component_decl::Ref>,
        directory_contents: DirectoryContents,
        responder: RealmReadOnlyDirectoryResponder,
    },
    /// Creates and routes a new storage capability to the provided targets.
    /// Optionally can connect the provided channel the the
    /// `fuchsia.sys2.StorageAdmin` protocol for this storage capability.
    AddStorage {
        name: String,
        to: Vec<fidl_fuchsia_component_decl::Ref>,
        storage_admin:
            Option<fidl::endpoints::ServerEnd<fidl_fuchsia_component::StorageAdminMarker>>,
        responder: RealmAddStorageResponder,
    },
    /// Load any packaged configuration for `name` before using values provided to
    /// the builder.
    ///
    /// Allows calling `SetConfigValue` to override packaged configuration.
    InitMutableConfigFromPackage {
        name: String,
        responder: RealmInitMutableConfigFromPackageResponder,
    },
    /// Use only values provided to the builder for `name`'s configuration.
    ///
    /// Allows calling `SetConfigValue` to provide configuration.
    InitMutableConfigToEmpty { name: String, responder: RealmInitMutableConfigToEmptyResponder },
    /// Add a capability to the realm.
    AddCapability {
        capability: fidl_fuchsia_component_decl::Capability,
        responder: RealmAddCapabilityResponder,
    },
    /// Adds a collection to the realm.
    AddCollection {
        collection: fidl_fuchsia_component_decl::Collection,
        responder: RealmAddCollectionResponder,
    },
    /// Adds an environment to the realm.
    AddEnvironment {
        environment: fidl_fuchsia_component_decl::Environment,
        responder: RealmAddEnvironmentResponder,
    },
    /// Sets the configuration value for a field specified by `key`.
    /// The component specified must have a config schema with this field.
    /// The value must conform to all constraints as defined by the schema.
    ///
    /// This method must be called after either `InitMutableConfigFromPackage` or
    /// `InitMutableConfigToEmpty`.
    ///
    /// Errors:
    /// - `NO_CONFIG_SCHEMA`: component does not have a config schema
    /// - `NO_SUCH_CONFIG_FIELD`: `key` could not be found in component's config schema
    /// - `CONFIG_VALUE_INVALID`: `value` does not meet config schema constraints
    SetConfigValue {
        name: String,
        key: String,
        value: fidl_fuchsia_component_decl::ConfigValueSpec,
        responder: RealmSetConfigValueResponder,
    },
}

impl RealmRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_add_child(self) -> Option<(String, String, ChildOptions, RealmAddChildResponder)> {
        if let RealmRequest::AddChild { name, url, options, responder } = self {
            Some((name, url, options, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_child_from_decl(
        self,
    ) -> Option<(
        String,
        fidl_fuchsia_component_decl::Component,
        ChildOptions,
        RealmAddChildFromDeclResponder,
    )> {
        if let RealmRequest::AddChildFromDecl { name, decl, options, responder } = self {
            Some((name, decl, options, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_local_child(
        self,
    ) -> Option<(String, ChildOptions, RealmAddLocalChildResponder)> {
        if let RealmRequest::AddLocalChild { name, options, responder } = self {
            Some((name, options, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_child_realm(
        self,
    ) -> Option<(
        String,
        ChildOptions,
        fidl::endpoints::ServerEnd<RealmMarker>,
        RealmAddChildRealmResponder,
    )> {
        if let RealmRequest::AddChildRealm { name, options, child_realm, responder } = self {
            Some((name, options, child_realm, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_child_realm_from_relative_url(
        self,
    ) -> Option<(
        String,
        String,
        ChildOptions,
        fidl::endpoints::ServerEnd<RealmMarker>,
        RealmAddChildRealmFromRelativeUrlResponder,
    )> {
        if let RealmRequest::AddChildRealmFromRelativeUrl {
            name,
            relative_url,
            options,
            child_realm,
            responder,
        } = self
        {
            Some((name, relative_url, options, child_realm, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_child_realm_from_decl(
        self,
    ) -> Option<(
        String,
        fidl_fuchsia_component_decl::Component,
        ChildOptions,
        fidl::endpoints::ServerEnd<RealmMarker>,
        RealmAddChildRealmFromDeclResponder,
    )> {
        if let RealmRequest::AddChildRealmFromDecl { name, decl, options, child_realm, responder } =
            self
        {
            Some((name, decl, options, child_realm, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_component_decl(self) -> Option<(String, RealmGetComponentDeclResponder)> {
        if let RealmRequest::GetComponentDecl { name, responder } = self {
            Some((name, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_replace_component_decl(
        self,
    ) -> Option<(String, fidl_fuchsia_component_decl::Component, RealmReplaceComponentDeclResponder)>
    {
        if let RealmRequest::ReplaceComponentDecl { name, component_decl, responder } = self {
            Some((name, component_decl, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_realm_decl(self) -> Option<(RealmGetRealmDeclResponder)> {
        if let RealmRequest::GetRealmDecl { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_replace_realm_decl(
        self,
    ) -> Option<(fidl_fuchsia_component_decl::Component, RealmReplaceRealmDeclResponder)> {
        if let RealmRequest::ReplaceRealmDecl { component_decl, responder } = self {
            Some((component_decl, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_use_nested_component_manager(
        self,
    ) -> Option<(String, RealmUseNestedComponentManagerResponder)> {
        if let RealmRequest::UseNestedComponentManager {
            component_manager_relative_url,
            responder,
        } = self
        {
            Some((component_manager_relative_url, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_route(
        self,
    ) -> Option<(
        Vec<Capability>,
        fidl_fuchsia_component_decl::Ref,
        Vec<fidl_fuchsia_component_decl::Ref>,
        RealmAddRouteResponder,
    )> {
        if let RealmRequest::AddRoute { capabilities, from, to, responder } = self {
            Some((capabilities, from, to, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_route_from_dictionary(
        self,
    ) -> Option<(
        Vec<Capability>,
        fidl_fuchsia_component_decl::Ref,
        String,
        Vec<fidl_fuchsia_component_decl::Ref>,
        RealmAddRouteFromDictionaryResponder,
    )> {
        if let RealmRequest::AddRouteFromDictionary {
            capabilities,
            from,
            from_dictionary,
            to,
            responder,
        } = self
        {
            Some((capabilities, from, from_dictionary, to, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_read_only_directory(
        self,
    ) -> Option<(
        String,
        Vec<fidl_fuchsia_component_decl::Ref>,
        DirectoryContents,
        RealmReadOnlyDirectoryResponder,
    )> {
        if let RealmRequest::ReadOnlyDirectory { name, to, directory_contents, responder } = self {
            Some((name, to, directory_contents, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_storage(
        self,
    ) -> Option<(
        String,
        Vec<fidl_fuchsia_component_decl::Ref>,
        Option<fidl::endpoints::ServerEnd<fidl_fuchsia_component::StorageAdminMarker>>,
        RealmAddStorageResponder,
    )> {
        if let RealmRequest::AddStorage { name, to, storage_admin, responder } = self {
            Some((name, to, storage_admin, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_init_mutable_config_from_package(
        self,
    ) -> Option<(String, RealmInitMutableConfigFromPackageResponder)> {
        if let RealmRequest::InitMutableConfigFromPackage { name, responder } = self {
            Some((name, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_init_mutable_config_to_empty(
        self,
    ) -> Option<(String, RealmInitMutableConfigToEmptyResponder)> {
        if let RealmRequest::InitMutableConfigToEmpty { name, responder } = self {
            Some((name, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_capability(
        self,
    ) -> Option<(fidl_fuchsia_component_decl::Capability, RealmAddCapabilityResponder)> {
        if let RealmRequest::AddCapability { capability, responder } = self {
            Some((capability, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_collection(
        self,
    ) -> Option<(fidl_fuchsia_component_decl::Collection, RealmAddCollectionResponder)> {
        if let RealmRequest::AddCollection { collection, responder } = self {
            Some((collection, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_environment(
        self,
    ) -> Option<(fidl_fuchsia_component_decl::Environment, RealmAddEnvironmentResponder)> {
        if let RealmRequest::AddEnvironment { environment, responder } = self {
            Some((environment, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_config_value(
        self,
    ) -> Option<(
        String,
        String,
        fidl_fuchsia_component_decl::ConfigValueSpec,
        RealmSetConfigValueResponder,
    )> {
        if let RealmRequest::SetConfigValue { name, key, value, responder } = self {
            Some((name, key, value, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            RealmRequest::AddChild { .. } => "add_child",
            RealmRequest::AddChildFromDecl { .. } => "add_child_from_decl",
            RealmRequest::AddLocalChild { .. } => "add_local_child",
            RealmRequest::AddChildRealm { .. } => "add_child_realm",
            RealmRequest::AddChildRealmFromRelativeUrl { .. } => {
                "add_child_realm_from_relative_url"
            }
            RealmRequest::AddChildRealmFromDecl { .. } => "add_child_realm_from_decl",
            RealmRequest::GetComponentDecl { .. } => "get_component_decl",
            RealmRequest::ReplaceComponentDecl { .. } => "replace_component_decl",
            RealmRequest::GetRealmDecl { .. } => "get_realm_decl",
            RealmRequest::ReplaceRealmDecl { .. } => "replace_realm_decl",
            RealmRequest::UseNestedComponentManager { .. } => "use_nested_component_manager",
            RealmRequest::AddRoute { .. } => "add_route",
            RealmRequest::AddRouteFromDictionary { .. } => "add_route_from_dictionary",
            RealmRequest::ReadOnlyDirectory { .. } => "read_only_directory",
            RealmRequest::AddStorage { .. } => "add_storage",
            RealmRequest::InitMutableConfigFromPackage { .. } => "init_mutable_config_from_package",
            RealmRequest::InitMutableConfigToEmpty { .. } => "init_mutable_config_to_empty",
            RealmRequest::AddCapability { .. } => "add_capability",
            RealmRequest::AddCollection { .. } => "add_collection",
            RealmRequest::AddEnvironment { .. } => "add_environment",
            RealmRequest::SetConfigValue { .. } => "set_config_value",
        }
    }
}

#[derive(Debug, Clone)]
pub struct RealmControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl RealmControlHandle {
    pub fn shutdown_with_epitaph(&self, status: impl Into<fidl::Epitaph>) {
        self.inner.shutdown_with_epitaph(status.into())
    }
}

impl fidl::endpoints::ControlHandle for RealmControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl RealmControlHandle {}

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

/// Set the the channel to be shutdown (see [`RealmControlHandle::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 RealmAddChildResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for RealmAddChildResponder {
    type ControlHandle = RealmControlHandle;

    fn control_handle(&self) -> &RealmControlHandle {
        &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 RealmAddChildResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), RealmBuilderError>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        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 result: Result<(), RealmBuilderError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), RealmBuilderError>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            RealmBuilderError,
        >>(
            result,
            self.tx_id,
            0x3f6c07627303d801,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`RealmControlHandle::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 RealmAddChildFromDeclResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for RealmAddChildFromDeclResponder {
    type ControlHandle = RealmControlHandle;

    fn control_handle(&self) -> &RealmControlHandle {
        &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 RealmAddChildFromDeclResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), RealmBuilderError>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        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 result: Result<(), RealmBuilderError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), RealmBuilderError>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            RealmBuilderError,
        >>(
            result,
            self.tx_id,
            0x3950ad500258156d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`RealmControlHandle::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 RealmAddLocalChildResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for RealmAddLocalChildResponder {
    type ControlHandle = RealmControlHandle;

    fn control_handle(&self) -> &RealmControlHandle {
        &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 RealmAddLocalChildResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), RealmBuilderError>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        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 result: Result<(), RealmBuilderError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), RealmBuilderError>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            RealmBuilderError,
        >>(
            result,
            self.tx_id,
            0x3249817bae10abbb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`RealmControlHandle::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 RealmAddChildRealmResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for RealmAddChildRealmResponder {
    type ControlHandle = RealmControlHandle;

    fn control_handle(&self) -> &RealmControlHandle {
        &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 RealmAddChildRealmResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), RealmBuilderError>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        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 result: Result<(), RealmBuilderError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), RealmBuilderError>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            RealmBuilderError,
        >>(
            result,
            self.tx_id,
            0x3fdf98db373b9458,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`RealmControlHandle::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 RealmAddChildRealmFromRelativeUrlResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for RealmAddChildRealmFromRelativeUrlResponder {
    type ControlHandle = RealmControlHandle;

    fn control_handle(&self) -> &RealmControlHandle {
        &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 RealmAddChildRealmFromRelativeUrlResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), RealmBuilderError>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        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 result: Result<(), RealmBuilderError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), RealmBuilderError>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            RealmBuilderError,
        >>(
            result,
            self.tx_id,
            0x44c34c8dcbe06abb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`RealmControlHandle::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 RealmAddChildRealmFromDeclResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for RealmAddChildRealmFromDeclResponder {
    type ControlHandle = RealmControlHandle;

    fn control_handle(&self) -> &RealmControlHandle {
        &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 RealmAddChildRealmFromDeclResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), RealmBuilderError>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        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 result: Result<(), RealmBuilderError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), RealmBuilderError>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            RealmBuilderError,
        >>(
            result,
            self.tx_id,
            0x142e5c326732862e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`RealmControlHandle::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 RealmGetComponentDeclResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for RealmGetComponentDeclResponder {
    type ControlHandle = RealmControlHandle;

    fn control_handle(&self) -> &RealmControlHandle {
        &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 RealmGetComponentDeclResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&fidl_fuchsia_component_decl::Component, RealmBuilderError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        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 result: Result<&fidl_fuchsia_component_decl::Component, RealmBuilderError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&fidl_fuchsia_component_decl::Component, RealmBuilderError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            RealmGetComponentDeclResponse,
            RealmBuilderError,
        >>(
            result.map(|component_decl| (component_decl,)),
            self.tx_id,
            0x320832af6a4cbac6,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`RealmControlHandle::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 RealmReplaceComponentDeclResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for RealmReplaceComponentDeclResponder {
    type ControlHandle = RealmControlHandle;

    fn control_handle(&self) -> &RealmControlHandle {
        &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 RealmReplaceComponentDeclResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), RealmBuilderError>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        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 result: Result<(), RealmBuilderError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), RealmBuilderError>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            RealmBuilderError,
        >>(
            result,
            self.tx_id,
            0x59cecf31b314cd5f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`RealmControlHandle::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 RealmGetRealmDeclResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for RealmGetRealmDeclResponder {
    type ControlHandle = RealmControlHandle;

    fn control_handle(&self) -> &RealmControlHandle {
        &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 RealmGetRealmDeclResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&fidl_fuchsia_component_decl::Component, RealmBuilderError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        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 result: Result<&fidl_fuchsia_component_decl::Component, RealmBuilderError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&fidl_fuchsia_component_decl::Component, RealmBuilderError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            RealmGetRealmDeclResponse,
            RealmBuilderError,
        >>(
            result.map(|component_decl| (component_decl,)),
            self.tx_id,
            0x46fa05b17bd64269,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`RealmControlHandle::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 RealmReplaceRealmDeclResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for RealmReplaceRealmDeclResponder {
    type ControlHandle = RealmControlHandle;

    fn control_handle(&self) -> &RealmControlHandle {
        &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 RealmReplaceRealmDeclResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), RealmBuilderError>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        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 result: Result<(), RealmBuilderError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), RealmBuilderError>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            RealmBuilderError,
        >>(
            result,
            self.tx_id,
            0x48fcba4ac1338da9,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`RealmControlHandle::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 RealmUseNestedComponentManagerResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for RealmUseNestedComponentManagerResponder {
    type ControlHandle = RealmControlHandle;

    fn control_handle(&self) -> &RealmControlHandle {
        &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 RealmUseNestedComponentManagerResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), RealmBuilderError>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        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 result: Result<(), RealmBuilderError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), RealmBuilderError>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            RealmBuilderError,
        >>(
            result,
            self.tx_id,
            0x64bd27482f3dcc,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`RealmControlHandle::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 RealmAddRouteResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for RealmAddRouteResponder {
    type ControlHandle = RealmControlHandle;

    fn control_handle(&self) -> &RealmControlHandle {
        &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 RealmAddRouteResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), RealmBuilderError>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        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 result: Result<(), RealmBuilderError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), RealmBuilderError>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            RealmBuilderError,
        >>(
            result,
            self.tx_id,
            0x9d523295be53a0a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`RealmControlHandle::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 RealmAddRouteFromDictionaryResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for RealmAddRouteFromDictionaryResponder {
    type ControlHandle = RealmControlHandle;

    fn control_handle(&self) -> &RealmControlHandle {
        &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 RealmAddRouteFromDictionaryResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), RealmBuilderError>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        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 result: Result<(), RealmBuilderError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), RealmBuilderError>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            RealmBuilderError,
        >>(
            result,
            self.tx_id,
            0x21fac42c3e1d14d2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`RealmControlHandle::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 RealmReadOnlyDirectoryResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for RealmReadOnlyDirectoryResponder {
    type ControlHandle = RealmControlHandle;

    fn control_handle(&self) -> &RealmControlHandle {
        &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 RealmReadOnlyDirectoryResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), RealmBuilderError>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        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 result: Result<(), RealmBuilderError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), RealmBuilderError>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            RealmBuilderError,
        >>(
            result,
            self.tx_id,
            0x78a6d150a66e00dc,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`RealmControlHandle::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 RealmAddStorageResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for RealmAddStorageResponder {
    type ControlHandle = RealmControlHandle;

    fn control_handle(&self) -> &RealmControlHandle {
        &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 RealmAddStorageResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), RealmBuilderError>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        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 result: Result<(), RealmBuilderError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), RealmBuilderError>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            RealmBuilderError,
        >>(
            result,
            self.tx_id,
            0x4709da0c9576b7c1,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`RealmControlHandle::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 RealmInitMutableConfigFromPackageResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for RealmInitMutableConfigFromPackageResponder {
    type ControlHandle = RealmControlHandle;

    fn control_handle(&self) -> &RealmControlHandle {
        &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 RealmInitMutableConfigFromPackageResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), RealmBuilderError>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        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 result: Result<(), RealmBuilderError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), RealmBuilderError>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            RealmBuilderError,
        >>(
            result,
            self.tx_id,
            0x36a30c9837c64216,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`RealmControlHandle::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 RealmInitMutableConfigToEmptyResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for RealmInitMutableConfigToEmptyResponder {
    type ControlHandle = RealmControlHandle;

    fn control_handle(&self) -> &RealmControlHandle {
        &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 RealmInitMutableConfigToEmptyResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), RealmBuilderError>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        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 result: Result<(), RealmBuilderError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), RealmBuilderError>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            RealmBuilderError,
        >>(
            result,
            self.tx_id,
            0x772cb99e2e0dccc5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`RealmControlHandle::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 RealmAddCapabilityResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for RealmAddCapabilityResponder {
    type ControlHandle = RealmControlHandle;

    fn control_handle(&self) -> &RealmControlHandle {
        &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 RealmAddCapabilityResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), RealmBuilderError>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        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 result: Result<(), RealmBuilderError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), RealmBuilderError>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            RealmBuilderError,
        >>(
            result,
            self.tx_id,
            0x23a6499eb6080249,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`RealmControlHandle::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 RealmAddCollectionResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for RealmAddCollectionResponder {
    type ControlHandle = RealmControlHandle;

    fn control_handle(&self) -> &RealmControlHandle {
        &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 RealmAddCollectionResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), RealmBuilderError>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        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 result: Result<(), RealmBuilderError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), RealmBuilderError>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            RealmBuilderError,
        >>(
            result,
            self.tx_id,
            0x56b75210a03a99b5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`RealmControlHandle::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 RealmAddEnvironmentResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for RealmAddEnvironmentResponder {
    type ControlHandle = RealmControlHandle;

    fn control_handle(&self) -> &RealmControlHandle {
        &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 RealmAddEnvironmentResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), RealmBuilderError>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        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 result: Result<(), RealmBuilderError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), RealmBuilderError>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            RealmBuilderError,
        >>(
            result,
            self.tx_id,
            0x1cd7caefa2cce0e9,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`RealmControlHandle::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 RealmSetConfigValueResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for RealmSetConfigValueResponder {
    type ControlHandle = RealmControlHandle;

    fn control_handle(&self) -> &RealmControlHandle {
        &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 RealmSetConfigValueResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), RealmBuilderError>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        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 result: Result<(), RealmBuilderError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), RealmBuilderError>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            RealmBuilderError,
        >>(
            result,
            self.tx_id,
            0x886450d291217f2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for RealmBuilderFactoryMarker {
    type Proxy = RealmBuilderFactoryProxy;
    type RequestStream = RealmBuilderFactoryRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = RealmBuilderFactorySynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.component.test.RealmBuilderFactory";
}
impl fidl::endpoints::DiscoverableProtocolMarker for RealmBuilderFactoryMarker {}
pub type RealmBuilderFactoryCreateResult = Result<(), RealmBuilderError>;
pub type RealmBuilderFactoryCreateFromRelativeUrlResult = Result<(), RealmBuilderError>;

pub trait RealmBuilderFactoryProxyInterface: Send + Sync {
    type CreateResponseFut: std::future::Future<Output = Result<RealmBuilderFactoryCreateResult, fidl::Error>>
        + Send;
    fn r#create(
        &self,
        pkg_dir_handle: fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
        realm_server_end: fidl::endpoints::ServerEnd<RealmMarker>,
        builder_server_end: fidl::endpoints::ServerEnd<BuilderMarker>,
    ) -> Self::CreateResponseFut;
    type CreateFromRelativeUrlResponseFut: std::future::Future<
            Output = Result<RealmBuilderFactoryCreateFromRelativeUrlResult, fidl::Error>,
        > + Send;
    fn r#create_from_relative_url(
        &self,
        pkg_dir_handle: fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
        relative_url: &str,
        realm_server_end: fidl::endpoints::ServerEnd<RealmMarker>,
        builder_server_end: fidl::endpoints::ServerEnd<BuilderMarker>,
    ) -> Self::CreateFromRelativeUrlResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct RealmBuilderFactorySynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for RealmBuilderFactorySynchronousProxy {
    type Proxy = RealmBuilderFactoryProxy;
    type Protocol = RealmBuilderFactoryMarker;

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

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

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

#[cfg(target_os = "fuchsia")]
impl RealmBuilderFactorySynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<RealmBuilderFactoryEvent, fidl::Error> {
        RealmBuilderFactoryEvent::decode(
            self.client.wait_for_event::<RealmBuilderFactoryMarker>(deadline)?,
        )
    }

    /// Creates a new RealmBuilder. The client end of `realm_server_end` can be
    /// used to mutate the realm that is being constructed, by doing things such
    /// as adding new children to the realm or adding capability routes between
    /// them. The client end of `builder_server_end` is used to finalize the
    /// realm, after which point it can be launched in a collection.
    ///
    /// `pkg_dir_handle` is a handle to the test package. The realm builder
    /// client typically passes a handle to its own `/pkg` directory, and
    /// bundles the `other-component` into the same package.
    pub fn r#create(
        &self,
        mut pkg_dir_handle: fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
        mut realm_server_end: fidl::endpoints::ServerEnd<RealmMarker>,
        mut builder_server_end: fidl::endpoints::ServerEnd<BuilderMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RealmBuilderFactoryCreateResult, fidl::Error> {
        let _response =
            self.client.send_query::<RealmBuilderFactoryCreateRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                RealmBuilderError,
            >, RealmBuilderFactoryMarker>(
                (pkg_dir_handle, realm_server_end, builder_server_end),
                0x73528b1135cb01be,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Identical to `Create`, but instead of the realm being empty by default
    /// it contains the contents of the manifest located in the test package at
    /// the path indicated by `relative_url`, which must be a fragment-only URL
    /// (for example, `#meta/other-component.cm`; see
    /// https://fuchsia.dev/fuchsia-src/reference/components/url#relative-fragment-only).
    pub fn r#create_from_relative_url(
        &self,
        mut pkg_dir_handle: fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
        mut relative_url: &str,
        mut realm_server_end: fidl::endpoints::ServerEnd<RealmMarker>,
        mut builder_server_end: fidl::endpoints::ServerEnd<BuilderMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RealmBuilderFactoryCreateFromRelativeUrlResult, fidl::Error> {
        let _response = self.client.send_query::<
            RealmBuilderFactoryCreateFromRelativeUrlRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, RealmBuilderError>,
            RealmBuilderFactoryMarker,
        >(
            (pkg_dir_handle, relative_url, realm_server_end, builder_server_end,),
            0x1cafd9042c54a86b,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

#[cfg(target_os = "fuchsia")]
impl From<RealmBuilderFactorySynchronousProxy> for zx::NullableHandle {
    fn from(value: RealmBuilderFactorySynchronousProxy) -> Self {
        value.into_channel().into()
    }
}

#[cfg(target_os = "fuchsia")]
impl From<fidl::Channel> for RealmBuilderFactorySynchronousProxy {
    fn from(value: fidl::Channel) -> Self {
        Self::new(value)
    }
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::FromClient for RealmBuilderFactorySynchronousProxy {
    type Protocol = RealmBuilderFactoryMarker;

    fn from_client(value: fidl::endpoints::ClientEnd<RealmBuilderFactoryMarker>) -> Self {
        Self::new(value.into_channel())
    }
}

#[derive(Debug, Clone)]
pub struct RealmBuilderFactoryProxy {
    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl fidl::endpoints::Proxy for RealmBuilderFactoryProxy {
    type Protocol = RealmBuilderFactoryMarker;

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

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

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl RealmBuilderFactoryProxy {
    /// Create a new Proxy for fuchsia.component.test/RealmBuilderFactory.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <RealmBuilderFactoryMarker as fidl::endpoints::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) -> RealmBuilderFactoryEventStream {
        RealmBuilderFactoryEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Creates a new RealmBuilder. The client end of `realm_server_end` can be
    /// used to mutate the realm that is being constructed, by doing things such
    /// as adding new children to the realm or adding capability routes between
    /// them. The client end of `builder_server_end` is used to finalize the
    /// realm, after which point it can be launched in a collection.
    ///
    /// `pkg_dir_handle` is a handle to the test package. The realm builder
    /// client typically passes a handle to its own `/pkg` directory, and
    /// bundles the `other-component` into the same package.
    pub fn r#create(
        &self,
        mut pkg_dir_handle: fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
        mut realm_server_end: fidl::endpoints::ServerEnd<RealmMarker>,
        mut builder_server_end: fidl::endpoints::ServerEnd<BuilderMarker>,
    ) -> fidl::client::QueryResponseFut<
        RealmBuilderFactoryCreateResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RealmBuilderFactoryProxyInterface::r#create(
            self,
            pkg_dir_handle,
            realm_server_end,
            builder_server_end,
        )
    }

    /// Identical to `Create`, but instead of the realm being empty by default
    /// it contains the contents of the manifest located in the test package at
    /// the path indicated by `relative_url`, which must be a fragment-only URL
    /// (for example, `#meta/other-component.cm`; see
    /// https://fuchsia.dev/fuchsia-src/reference/components/url#relative-fragment-only).
    pub fn r#create_from_relative_url(
        &self,
        mut pkg_dir_handle: fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
        mut relative_url: &str,
        mut realm_server_end: fidl::endpoints::ServerEnd<RealmMarker>,
        mut builder_server_end: fidl::endpoints::ServerEnd<BuilderMarker>,
    ) -> fidl::client::QueryResponseFut<
        RealmBuilderFactoryCreateFromRelativeUrlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RealmBuilderFactoryProxyInterface::r#create_from_relative_url(
            self,
            pkg_dir_handle,
            relative_url,
            realm_server_end,
            builder_server_end,
        )
    }
}

impl RealmBuilderFactoryProxyInterface for RealmBuilderFactoryProxy {
    type CreateResponseFut = fidl::client::QueryResponseFut<
        RealmBuilderFactoryCreateResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#create(
        &self,
        mut pkg_dir_handle: fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
        mut realm_server_end: fidl::endpoints::ServerEnd<RealmMarker>,
        mut builder_server_end: fidl::endpoints::ServerEnd<BuilderMarker>,
    ) -> Self::CreateResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RealmBuilderFactoryCreateResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, RealmBuilderError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x73528b1135cb01be,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            RealmBuilderFactoryCreateRequest,
            RealmBuilderFactoryCreateResult,
        >(
            (pkg_dir_handle, realm_server_end, builder_server_end,),
            0x73528b1135cb01be,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type CreateFromRelativeUrlResponseFut = fidl::client::QueryResponseFut<
        RealmBuilderFactoryCreateFromRelativeUrlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#create_from_relative_url(
        &self,
        mut pkg_dir_handle: fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
        mut relative_url: &str,
        mut realm_server_end: fidl::endpoints::ServerEnd<RealmMarker>,
        mut builder_server_end: fidl::endpoints::ServerEnd<BuilderMarker>,
    ) -> Self::CreateFromRelativeUrlResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RealmBuilderFactoryCreateFromRelativeUrlResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, RealmBuilderError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1cafd9042c54a86b,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            RealmBuilderFactoryCreateFromRelativeUrlRequest,
            RealmBuilderFactoryCreateFromRelativeUrlResult,
        >(
            (pkg_dir_handle, relative_url, realm_server_end, builder_server_end,),
            0x1cafd9042c54a86b,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

pub struct RealmBuilderFactoryEventStream {
    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

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

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

impl futures::Stream for RealmBuilderFactoryEventStream {
    type Item = Result<RealmBuilderFactoryEvent, 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(RealmBuilderFactoryEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

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

impl RealmBuilderFactoryEvent {
    /// Decodes a message buffer as a [`RealmBuilderFactoryEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<RealmBuilderFactoryEvent, 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:
                    <RealmBuilderFactoryMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.component.test/RealmBuilderFactory.
pub struct RealmBuilderFactoryRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for RealmBuilderFactoryRequestStream {
    type Protocol = RealmBuilderFactoryMarker;
    type ControlHandle = RealmBuilderFactoryControlHandle;

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

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

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

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

impl futures::Stream for RealmBuilderFactoryRequestStream {
    type Item = Result<RealmBuilderFactoryRequest, 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 RealmBuilderFactoryRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |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(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(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 {
                0x73528b1135cb01be => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(RealmBuilderFactoryCreateRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RealmBuilderFactoryCreateRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = RealmBuilderFactoryControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(RealmBuilderFactoryRequest::Create {pkg_dir_handle: req.pkg_dir_handle,
realm_server_end: req.realm_server_end,
builder_server_end: req.builder_server_end,

                        responder: RealmBuilderFactoryCreateResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x1cafd9042c54a86b => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(RealmBuilderFactoryCreateFromRelativeUrlRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RealmBuilderFactoryCreateFromRelativeUrlRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = RealmBuilderFactoryControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(RealmBuilderFactoryRequest::CreateFromRelativeUrl {pkg_dir_handle: req.pkg_dir_handle,
relative_url: req.relative_url,
realm_server_end: req.realm_server_end,
builder_server_end: req.builder_server_end,

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

/// This protocol can be used to instruct the Realm Builder Server to begin
/// creating a new realm.
#[derive(Debug)]
pub enum RealmBuilderFactoryRequest {
    /// Creates a new RealmBuilder. The client end of `realm_server_end` can be
    /// used to mutate the realm that is being constructed, by doing things such
    /// as adding new children to the realm or adding capability routes between
    /// them. The client end of `builder_server_end` is used to finalize the
    /// realm, after which point it can be launched in a collection.
    ///
    /// `pkg_dir_handle` is a handle to the test package. The realm builder
    /// client typically passes a handle to its own `/pkg` directory, and
    /// bundles the `other-component` into the same package.
    Create {
        pkg_dir_handle: fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
        realm_server_end: fidl::endpoints::ServerEnd<RealmMarker>,
        builder_server_end: fidl::endpoints::ServerEnd<BuilderMarker>,
        responder: RealmBuilderFactoryCreateResponder,
    },
    /// Identical to `Create`, but instead of the realm being empty by default
    /// it contains the contents of the manifest located in the test package at
    /// the path indicated by `relative_url`, which must be a fragment-only URL
    /// (for example, `#meta/other-component.cm`; see
    /// https://fuchsia.dev/fuchsia-src/reference/components/url#relative-fragment-only).
    CreateFromRelativeUrl {
        pkg_dir_handle: fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
        relative_url: String,
        realm_server_end: fidl::endpoints::ServerEnd<RealmMarker>,
        builder_server_end: fidl::endpoints::ServerEnd<BuilderMarker>,
        responder: RealmBuilderFactoryCreateFromRelativeUrlResponder,
    },
}

impl RealmBuilderFactoryRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_create(
        self,
    ) -> Option<(
        fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
        fidl::endpoints::ServerEnd<RealmMarker>,
        fidl::endpoints::ServerEnd<BuilderMarker>,
        RealmBuilderFactoryCreateResponder,
    )> {
        if let RealmBuilderFactoryRequest::Create {
            pkg_dir_handle,
            realm_server_end,
            builder_server_end,
            responder,
        } = self
        {
            Some((pkg_dir_handle, realm_server_end, builder_server_end, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_create_from_relative_url(
        self,
    ) -> Option<(
        fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
        String,
        fidl::endpoints::ServerEnd<RealmMarker>,
        fidl::endpoints::ServerEnd<BuilderMarker>,
        RealmBuilderFactoryCreateFromRelativeUrlResponder,
    )> {
        if let RealmBuilderFactoryRequest::CreateFromRelativeUrl {
            pkg_dir_handle,
            relative_url,
            realm_server_end,
            builder_server_end,
            responder,
        } = self
        {
            Some((pkg_dir_handle, relative_url, realm_server_end, builder_server_end, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            RealmBuilderFactoryRequest::Create { .. } => "create",
            RealmBuilderFactoryRequest::CreateFromRelativeUrl { .. } => "create_from_relative_url",
        }
    }
}

#[derive(Debug, Clone)]
pub struct RealmBuilderFactoryControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl RealmBuilderFactoryControlHandle {
    pub fn shutdown_with_epitaph(&self, status: impl Into<fidl::Epitaph>) {
        self.inner.shutdown_with_epitaph(status.into())
    }
}

impl fidl::endpoints::ControlHandle for RealmBuilderFactoryControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl RealmBuilderFactoryControlHandle {}

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

/// Set the the channel to be shutdown (see [`RealmBuilderFactoryControlHandle::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 RealmBuilderFactoryCreateResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for RealmBuilderFactoryCreateResponder {
    type ControlHandle = RealmBuilderFactoryControlHandle;

    fn control_handle(&self) -> &RealmBuilderFactoryControlHandle {
        &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 RealmBuilderFactoryCreateResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), RealmBuilderError>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        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 result: Result<(), RealmBuilderError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), RealmBuilderError>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            RealmBuilderError,
        >>(
            result,
            self.tx_id,
            0x73528b1135cb01be,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`RealmBuilderFactoryControlHandle::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 RealmBuilderFactoryCreateFromRelativeUrlResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for RealmBuilderFactoryCreateFromRelativeUrlResponder {
    type ControlHandle = RealmBuilderFactoryControlHandle;

    fn control_handle(&self) -> &RealmBuilderFactoryControlHandle {
        &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 RealmBuilderFactoryCreateFromRelativeUrlResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), RealmBuilderError>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        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 result: Result<(), RealmBuilderError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), RealmBuilderError>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            RealmBuilderError,
        >>(
            result,
            self.tx_id,
            0x1cafd9042c54a86b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

mod internal {
    use super::*;

    impl fidl::encoding::ResourceTypeMarker for BuilderBuildRequest {
        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 BuilderBuildRequest {
        type Owned = Self;

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

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

    unsafe impl
        fidl::encoding::Encode<BuilderBuildRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut BuilderBuildRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<BuilderBuildRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                BuilderBuildRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<fidl::encoding::Endpoint<
                    fidl::endpoints::ClientEnd<
                        fidl_fuchsia_component_runner::ComponentRunnerMarker,
                    >,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.runner
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<
                    fidl::endpoints::ClientEnd<
                        fidl_fuchsia_component_runner::ComponentRunnerMarker,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    > fidl::encoding::Encode<BuilderBuildRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<BuilderBuildRequest>(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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for BuilderBuildRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                runner: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<
                            fidl_fuchsia_component_runner::ComponentRunnerMarker,
                        >,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for DirectoryContents {
        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 DirectoryContents {
        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<DirectoryContents, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut DirectoryContents
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DirectoryContents>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DirectoryContents, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Vector<DirectoryEntry, 1024> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.entries),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Vector<DirectoryEntry, 1024>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    > fidl::encoding::Encode<DirectoryContents, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DirectoryContents>(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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for DirectoryContents
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                entries: fidl::new_empty!(fidl::encoding::Vector<DirectoryEntry, 1024>, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for DirectoryEntry {
        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 DirectoryEntry {
        type Owned = Self;

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

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

    unsafe impl
        fidl::encoding::Encode<DirectoryEntry, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut DirectoryEntry
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DirectoryEntry>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DirectoryEntry, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(&self.file_path),
                    <fidl_fuchsia_mem::Buffer as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.file_contents),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::BoundedString<255>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl_fuchsia_mem::Buffer,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    > fidl::encoding::Encode<DirectoryEntry, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DirectoryEntry>(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 + 16, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for DirectoryEntry
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                file_path: fidl::new_empty!(
                    fidl::encoding::BoundedString<255>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                file_contents: fidl::new_empty!(
                    fidl_fuchsia_mem::Buffer,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::BoundedString<255>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.file_path,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl_fuchsia_mem::Buffer,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.file_contents,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for RealmAddChildRealmFromDeclRequest {
        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 RealmAddChildRealmFromDeclRequest {
        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<
            RealmAddChildRealmFromDeclRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut RealmAddChildRealmFromDeclRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RealmAddChildRealmFromDeclRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RealmAddChildRealmFromDeclRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
                    <fidl_fuchsia_component_decl::Component as fidl::encoding::ValueTypeMarker>::borrow(&self.decl),
                    <ChildOptions as fidl::encoding::ValueTypeMarker>::borrow(&self.options),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<RealmMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.child_realm),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::BoundedString<255>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl_fuchsia_component_decl::Component,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T2: fidl::encoding::Encode<ChildOptions, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T3: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<RealmMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            RealmAddChildRealmFromDeclRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2, T3)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RealmAddChildRealmFromDeclRequest>(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(48);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            self.2.encode(encoder, offset + 32, depth)?;
            self.3.encode(encoder, offset + 48, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for RealmAddChildRealmFromDeclRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                name: fidl::new_empty!(
                    fidl::encoding::BoundedString<255>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                decl: fidl::new_empty!(
                    fidl_fuchsia_component_decl::Component,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                options: fidl::new_empty!(
                    ChildOptions,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                child_realm: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<RealmMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            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(48) };
            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 + 48 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl::encoding::BoundedString<255>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.name,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl_fuchsia_component_decl::Component,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.decl,
                decoder,
                offset + 16,
                _depth
            )?;
            fidl::decode!(
                ChildOptions,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.options,
                decoder,
                offset + 32,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<RealmMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.child_realm,
                decoder,
                offset + 48,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for RealmAddChildRealmFromRelativeUrlRequest {
        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 RealmAddChildRealmFromRelativeUrlRequest {
        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<
            RealmAddChildRealmFromRelativeUrlRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut RealmAddChildRealmFromRelativeUrlRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RealmAddChildRealmFromRelativeUrlRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RealmAddChildRealmFromRelativeUrlRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
                    <fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(&self.relative_url),
                    <ChildOptions as fidl::encoding::ValueTypeMarker>::borrow(&self.options),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<RealmMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.child_realm),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::BoundedString<255>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::BoundedString<4096>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T2: fidl::encoding::Encode<ChildOptions, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T3: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<RealmMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            RealmAddChildRealmFromRelativeUrlRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2, T3)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RealmAddChildRealmFromRelativeUrlRequest>(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(48);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            self.2.encode(encoder, offset + 32, depth)?;
            self.3.encode(encoder, offset + 48, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for RealmAddChildRealmFromRelativeUrlRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                name: fidl::new_empty!(
                    fidl::encoding::BoundedString<255>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                relative_url: fidl::new_empty!(
                    fidl::encoding::BoundedString<4096>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                options: fidl::new_empty!(
                    ChildOptions,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                child_realm: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<RealmMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            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(48) };
            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 + 48 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl::encoding::BoundedString<255>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.name,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::BoundedString<4096>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.relative_url,
                decoder,
                offset + 16,
                _depth
            )?;
            fidl::decode!(
                ChildOptions,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.options,
                decoder,
                offset + 32,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<RealmMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.child_realm,
                decoder,
                offset + 48,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for RealmAddChildRealmRequest {
        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 RealmAddChildRealmRequest {
        type Owned = Self;

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

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

    unsafe impl
        fidl::encoding::Encode<
            RealmAddChildRealmRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut RealmAddChildRealmRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RealmAddChildRealmRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RealmAddChildRealmRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
                    <ChildOptions as fidl::encoding::ValueTypeMarker>::borrow(&self.options),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<RealmMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.child_realm),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::BoundedString<255>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T1: fidl::encoding::Encode<ChildOptions, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T2: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<RealmMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            RealmAddChildRealmRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RealmAddChildRealmRequest>(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(32);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            self.2.encode(encoder, offset + 32, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for RealmAddChildRealmRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                name: fidl::new_empty!(
                    fidl::encoding::BoundedString<255>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                options: fidl::new_empty!(
                    ChildOptions,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                child_realm: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<RealmMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            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(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::BoundedString<255>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.name,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                ChildOptions,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.options,
                decoder,
                offset + 16,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<RealmMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.child_realm,
                decoder,
                offset + 32,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for RealmAddStorageRequest {
        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 RealmAddStorageRequest {
        type Owned = Self;

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

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

    unsafe impl
        fidl::encoding::Encode<
            RealmAddStorageRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut RealmAddStorageRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RealmAddStorageRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RealmAddStorageRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
                    <fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl::Ref> as fidl::encoding::ValueTypeMarker>::borrow(&self.to),
                    <fidl::encoding::Optional<fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<fidl_fuchsia_component::StorageAdminMarker>>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.storage_admin),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::BoundedString<255>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl::Ref>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T2: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<fidl_fuchsia_component::StorageAdminMarker>,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            RealmAddStorageRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RealmAddStorageRequest>(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(32);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            self.2.encode(encoder, offset + 32, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for RealmAddStorageRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                name: fidl::new_empty!(
                    fidl::encoding::BoundedString<255>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                to: fidl::new_empty!(
                    fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl::Ref>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                storage_admin: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::Endpoint<
                            fidl::endpoints::ServerEnd<fidl_fuchsia_component::StorageAdminMarker>,
                        >,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            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(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::BoundedString<255>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.name,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl::Ref>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.to,
                decoder,
                offset + 16,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<fidl_fuchsia_component::StorageAdminMarker>,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.storage_admin,
                decoder,
                offset + 32,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for RealmBuilderFactoryCreateFromRelativeUrlRequest {
        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 RealmBuilderFactoryCreateFromRelativeUrlRequest {
        type Owned = Self;

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

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

    unsafe impl
        fidl::encoding::Encode<
            RealmBuilderFactoryCreateFromRelativeUrlRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut RealmBuilderFactoryCreateFromRelativeUrlRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RealmBuilderFactoryCreateFromRelativeUrlRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RealmBuilderFactoryCreateFromRelativeUrlRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.pkg_dir_handle),
                    <fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(&self.relative_url),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<RealmMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.realm_server_end),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<BuilderMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.builder_server_end),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<
                    fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::BoundedString<4096>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T2: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<RealmMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T3: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<BuilderMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            RealmBuilderFactoryCreateFromRelativeUrlRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2, T3)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RealmBuilderFactoryCreateFromRelativeUrlRequest>(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)?;
            self.2.encode(encoder, offset + 24, depth)?;
            self.3.encode(encoder, offset + 28, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for RealmBuilderFactoryCreateFromRelativeUrlRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                pkg_dir_handle: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                relative_url: fidl::new_empty!(
                    fidl::encoding::BoundedString<4096>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                realm_server_end: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<RealmMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                builder_server_end: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<BuilderMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            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!(
                fidl::encoding::Endpoint<
                    fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.pkg_dir_handle,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::BoundedString<4096>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.relative_url,
                decoder,
                offset + 8,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<RealmMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.realm_server_end,
                decoder,
                offset + 24,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<BuilderMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.builder_server_end,
                decoder,
                offset + 28,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for RealmBuilderFactoryCreateRequest {
        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 RealmBuilderFactoryCreateRequest {
        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<
            RealmBuilderFactoryCreateRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut RealmBuilderFactoryCreateRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RealmBuilderFactoryCreateRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RealmBuilderFactoryCreateRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.pkg_dir_handle),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<RealmMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.realm_server_end),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<BuilderMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.builder_server_end),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<
                    fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<RealmMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T2: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<BuilderMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            RealmBuilderFactoryCreateRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RealmBuilderFactoryCreateRequest>(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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for RealmBuilderFactoryCreateRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                pkg_dir_handle: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                realm_server_end: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<RealmMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                builder_server_end: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<BuilderMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Endpoint<
                    fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.pkg_dir_handle,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<RealmMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.realm_server_end,
                decoder,
                offset + 4,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<BuilderMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.builder_server_end,
                decoder,
                offset + 8,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for RealmReadOnlyDirectoryRequest {
        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 RealmReadOnlyDirectoryRequest {
        type Owned = Self;

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

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

    unsafe impl
        fidl::encoding::Encode<
            RealmReadOnlyDirectoryRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut RealmReadOnlyDirectoryRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RealmReadOnlyDirectoryRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RealmReadOnlyDirectoryRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
                    <fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl::Ref> as fidl::encoding::ValueTypeMarker>::borrow(&self.to),
                    <DirectoryContents as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.directory_contents),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::BoundedString<255>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl::Ref>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T2: fidl::encoding::Encode<DirectoryContents, fidl::encoding::DefaultFuchsiaResourceDialect>,
    >
        fidl::encoding::Encode<
            RealmReadOnlyDirectoryRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RealmReadOnlyDirectoryRequest>(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 + 16, depth)?;
            self.2.encode(encoder, offset + 32, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for RealmReadOnlyDirectoryRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                name: fidl::new_empty!(
                    fidl::encoding::BoundedString<255>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                to: fidl::new_empty!(
                    fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl::Ref>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                directory_contents: fidl::new_empty!(
                    DirectoryContents,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::BoundedString<255>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.name,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl::Ref>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.to,
                decoder,
                offset + 16,
                _depth
            )?;
            fidl::decode!(
                DirectoryContents,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.directory_contents,
                decoder,
                offset + 32,
                _depth
            )?;
            Ok(())
        }
    }
}