fdomain_fuchsia_sys2/

fdomain_fuchsia_sys2.rs

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

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

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct CrashIntrospectFindComponentByThreadKoidRequest {
    pub thread_koid: u64,
}

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

#[derive(Debug, PartialEq)]
pub struct LifecycleControllerCreateInstanceRequest {
    pub parent_moniker: String,
    pub collection: fdomain_fuchsia_component_decl::CollectionRef,
    pub decl: fdomain_fuchsia_component_decl::Child,
    pub args: fdomain_fuchsia_component::CreateChildArgs,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct LifecycleControllerStartInstanceRequest {
    pub moniker: String,
    pub binder: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_component::BinderMarker>,
}

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

#[derive(Debug, PartialEq)]
pub struct LifecycleControllerStartInstanceWithArgsRequest {
    pub moniker: String,
    pub binder: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_component::BinderMarker>,
    pub args: fdomain_fuchsia_component::StartChildArgs,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RealmQueryConnectToStorageAdminRequest {
    pub moniker: String,
    pub storage_name: String,
    pub server_end: fdomain_client::fidl::ServerEnd<StorageAdminMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RealmQueryOpenDirectoryRequest {
    pub moniker: String,
    pub dir_type: OpenDirType,
    pub object: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::DirectoryMarker>,
}

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

#[derive(Debug, PartialEq)]
pub struct RealmQueryConstructNamespaceResponse {
    /// The directory handles + paths that constitute the component's namespace.
    pub namespace: Vec<fdomain_fuchsia_component_runner::ComponentNamespaceEntry>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RealmQueryGetAllInstancesResponse {
    pub iterator: fdomain_client::fidl::ClientEnd<InstanceIteratorMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RealmQueryGetResolvedDeclarationResponse {
    pub iterator: fdomain_client::fidl::ClientEnd<ManifestBytesIteratorMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RealmQueryResolveDeclarationResponse {
    pub iterator: fdomain_client::fidl::ClientEnd<ManifestBytesIteratorMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct StorageAdminListStorageInRealmRequest {
    pub relative_moniker: String,
    pub iterator: fdomain_client::fidl::ServerEnd<StorageIteratorMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct StorageAdminOpenComponentStorageByIdRequest {
    pub id: String,
    pub object: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::NodeMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct StorageAdminOpenStorageRequest {
    pub relative_moniker: String,
    pub object: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::NodeMarker>,
}

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

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

impl fdomain_client::fidl::ProtocolMarker for BootControllerMarker {
    type Proxy = BootControllerProxy;
    type RequestStream = BootControllerRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.sys2.BootController";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for BootControllerMarker {}

pub trait BootControllerProxyInterface: Send + Sync {
    type NotifyResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#notify(&self) -> Self::NotifyResponseFut;
}

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

impl fdomain_client::fidl::Proxy for BootControllerProxy {
    type Protocol = BootControllerMarker;

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

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

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

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

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

    pub fn r#notify(
        &self,
    ) -> fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect> {
        BootControllerProxyInterface::r#notify(self)
    }
}

impl BootControllerProxyInterface for BootControllerProxy {
    type NotifyResponseFut =
        fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect>;
    fn r#notify(&self) -> Self::NotifyResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x55173ddd1d9ed8de,
            >(_buf?)?
            .into_result_fdomain::<BootControllerMarker>("notify")?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
            (),
            0x55173ddd1d9ed8de,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }
}

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

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

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

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

#[derive(Debug)]
pub enum BootControllerEvent {
    #[non_exhaustive]
    _UnknownEvent {
        /// Ordinal of the event that was sent.
        ordinal: u64,
    },
}

impl BootControllerEvent {
    /// Decodes a message buffer as a [`BootControllerEvent`].
    fn decode(
        mut buf: <fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<BootControllerEvent, 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 {
            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                Ok(BootControllerEvent::_UnknownEvent { ordinal: tx_header.ordinal })
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name:
                    <BootControllerMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fdomain_client::fidl::RequestStream for BootControllerRequestStream {
    type Protocol = BootControllerMarker;
    type ControlHandle = BootControllerControlHandle;

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

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

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

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

impl futures::Stream for BootControllerRequestStream {
    type Item = Result<BootControllerRequest, 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 BootControllerRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(e))) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

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

                std::task::Poll::Ready(Some(match header.ordinal {
                0x55173ddd1d9ed8de => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BootControllerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BootControllerRequest::Notify {
                        responder: BootControllerNotifyResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                _ if header.tx_id == 0 && header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                    Ok(BootControllerRequest::_UnknownMethod {
                        ordinal: header.ordinal,
                        control_handle: BootControllerControlHandle { inner: this.inner.clone() },
                        method_type: fidl::MethodType::OneWay,
                    })
                }
                _ if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                    this.inner.send_framework_err(
                        fidl::encoding::FrameworkErr::UnknownMethod,
                        header.tx_id,
                        header.ordinal,
                        header.dynamic_flags(),
                        (bytes, handles),
                    )?;
                    Ok(BootControllerRequest::_UnknownMethod {
                        ordinal: header.ordinal,
                        control_handle: BootControllerControlHandle { inner: this.inner.clone() },
                        method_type: fidl::MethodType::TwoWay,
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <BootControllerMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

#[derive(Debug)]
pub enum BootControllerRequest {
    Notify {
        responder: BootControllerNotifyResponder,
    },
    /// An interaction was received which does not match any known method.
    #[non_exhaustive]
    _UnknownMethod {
        /// Ordinal of the method that was called.
        ordinal: u64,
        control_handle: BootControllerControlHandle,
        method_type: fidl::MethodType,
    },
}

impl BootControllerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_notify(self) -> Option<(BootControllerNotifyResponder)> {
        if let BootControllerRequest::Notify { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            BootControllerRequest::Notify { .. } => "notify",
            BootControllerRequest::_UnknownMethod {
                method_type: fidl::MethodType::OneWay, ..
            } => "unknown one-way method",
            BootControllerRequest::_UnknownMethod {
                method_type: fidl::MethodType::TwoWay, ..
            } => "unknown two-way method",
        }
    }
}

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

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

    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

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

impl BootControllerControlHandle {}

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

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

impl fdomain_client::fidl::Responder for BootControllerNotifyResponder {
    type ControlHandle = BootControllerControlHandle;

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

    fn send_raw(&self) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>>(
            fidl::encoding::Flexible::new(()),
            self.tx_id,
            0x55173ddd1d9ed8de,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

impl fdomain_client::fidl::ProtocolMarker for ConfigOverrideMarker {
    type Proxy = ConfigOverrideProxy;
    type RequestStream = ConfigOverrideRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.sys2.ConfigOverride";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for ConfigOverrideMarker {}
pub type ConfigOverrideSetStructuredConfigResult = Result<(), ConfigOverrideError>;
pub type ConfigOverrideUnsetStructuredConfigResult = Result<(), ConfigOverrideError>;

pub trait ConfigOverrideProxyInterface: Send + Sync {
    type SetStructuredConfigResponseFut: std::future::Future<Output = Result<ConfigOverrideSetStructuredConfigResult, fidl::Error>>
        + Send;
    fn r#set_structured_config(
        &self,
        moniker: &str,
        fields: &[fdomain_fuchsia_component_decl::ConfigOverride],
    ) -> Self::SetStructuredConfigResponseFut;
    type UnsetStructuredConfigResponseFut: std::future::Future<Output = Result<ConfigOverrideUnsetStructuredConfigResult, fidl::Error>>
        + Send;
    fn r#unset_structured_config(&self, moniker: &str) -> Self::UnsetStructuredConfigResponseFut;
}

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

impl fdomain_client::fidl::Proxy for ConfigOverrideProxy {
    type Protocol = ConfigOverrideMarker;

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

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

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

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

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

    /// Sets structured configuration fields with override values for the
    /// component instance identified by moniker.
    pub fn r#set_structured_config(
        &self,
        mut moniker: &str,
        mut fields: &[fdomain_fuchsia_component_decl::ConfigOverride],
    ) -> fidl::client::QueryResponseFut<
        ConfigOverrideSetStructuredConfigResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        ConfigOverrideProxyInterface::r#set_structured_config(self, moniker, fields)
    }

    /// Unsets structured configuration overrides for the component instance
    /// identified by moniker.  If an empty moniker is supplied, then all
    /// structured configuration overrides will be cleared.
    pub fn r#unset_structured_config(
        &self,
        mut moniker: &str,
    ) -> fidl::client::QueryResponseFut<
        ConfigOverrideUnsetStructuredConfigResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        ConfigOverrideProxyInterface::r#unset_structured_config(self, moniker)
    }
}

impl ConfigOverrideProxyInterface for ConfigOverrideProxy {
    type SetStructuredConfigResponseFut = fidl::client::QueryResponseFut<
        ConfigOverrideSetStructuredConfigResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#set_structured_config(
        &self,
        mut moniker: &str,
        mut fields: &[fdomain_fuchsia_component_decl::ConfigOverride],
    ) -> Self::SetStructuredConfigResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ConfigOverrideSetStructuredConfigResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<
                    fidl::encoding::EmptyStruct,
                    ConfigOverrideError,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                0x2c6a138832d2e0ee,
            >(_buf?)?
            .into_result_fdomain::<ConfigOverrideMarker>("set_structured_config")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            ConfigOverrideSetStructuredConfigRequest,
            ConfigOverrideSetStructuredConfigResult,
        >(
            (moniker, fields,),
            0x2c6a138832d2e0ee,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type UnsetStructuredConfigResponseFut = fidl::client::QueryResponseFut<
        ConfigOverrideUnsetStructuredConfigResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#unset_structured_config(
        &self,
        mut moniker: &str,
    ) -> Self::UnsetStructuredConfigResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ConfigOverrideUnsetStructuredConfigResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<
                    fidl::encoding::EmptyStruct,
                    ConfigOverrideError,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                0x342ec7d2bef05552,
            >(_buf?)?
            .into_result_fdomain::<ConfigOverrideMarker>("unset_structured_config")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            ConfigOverrideUnsetStructuredConfigRequest,
            ConfigOverrideUnsetStructuredConfigResult,
        >(
            (moniker,),
            0x342ec7d2bef05552,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }
}

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

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

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

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

#[derive(Debug)]
pub enum ConfigOverrideEvent {
    #[non_exhaustive]
    _UnknownEvent {
        /// Ordinal of the event that was sent.
        ordinal: u64,
    },
}

impl ConfigOverrideEvent {
    /// Decodes a message buffer as a [`ConfigOverrideEvent`].
    fn decode(
        mut buf: <fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<ConfigOverrideEvent, 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 {
            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                Ok(ConfigOverrideEvent::_UnknownEvent { ordinal: tx_header.ordinal })
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name:
                    <ConfigOverrideMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fdomain_client::fidl::RequestStream for ConfigOverrideRequestStream {
    type Protocol = ConfigOverrideMarker;
    type ControlHandle = ConfigOverrideControlHandle;

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

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

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

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

impl futures::Stream for ConfigOverrideRequestStream {
    type Item = Result<ConfigOverrideRequest, 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 ConfigOverrideRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(e))) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

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

                std::task::Poll::Ready(Some(match header.ordinal {
                0x2c6a138832d2e0ee => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(ConfigOverrideSetStructuredConfigRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<ConfigOverrideSetStructuredConfigRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = ConfigOverrideControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(ConfigOverrideRequest::SetStructuredConfig {moniker: req.moniker,
fields: req.fields,

                        responder: ConfigOverrideSetStructuredConfigResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x342ec7d2bef05552 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(ConfigOverrideUnsetStructuredConfigRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<ConfigOverrideUnsetStructuredConfigRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = ConfigOverrideControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(ConfigOverrideRequest::UnsetStructuredConfig {moniker: req.moniker,

                        responder: ConfigOverrideUnsetStructuredConfigResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                _ if header.tx_id == 0 && header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                    Ok(ConfigOverrideRequest::_UnknownMethod {
                        ordinal: header.ordinal,
                        control_handle: ConfigOverrideControlHandle { inner: this.inner.clone() },
                        method_type: fidl::MethodType::OneWay,
                    })
                }
                _ if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                    this.inner.send_framework_err(
                        fidl::encoding::FrameworkErr::UnknownMethod,
                        header.tx_id,
                        header.ordinal,
                        header.dynamic_flags(),
                        (bytes, handles),
                    )?;
                    Ok(ConfigOverrideRequest::_UnknownMethod {
                        ordinal: header.ordinal,
                        control_handle: ConfigOverrideControlHandle { inner: this.inner.clone() },
                        method_type: fidl::MethodType::TwoWay,
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <ConfigOverrideMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// Manages structured configuration override values for components.
#[derive(Debug)]
pub enum ConfigOverrideRequest {
    /// Sets structured configuration fields with override values for the
    /// component instance identified by moniker.
    SetStructuredConfig {
        moniker: String,
        fields: Vec<fdomain_fuchsia_component_decl::ConfigOverride>,
        responder: ConfigOverrideSetStructuredConfigResponder,
    },
    /// Unsets structured configuration overrides for the component instance
    /// identified by moniker.  If an empty moniker is supplied, then all
    /// structured configuration overrides will be cleared.
    UnsetStructuredConfig {
        moniker: String,
        responder: ConfigOverrideUnsetStructuredConfigResponder,
    },
    /// An interaction was received which does not match any known method.
    #[non_exhaustive]
    _UnknownMethod {
        /// Ordinal of the method that was called.
        ordinal: u64,
        control_handle: ConfigOverrideControlHandle,
        method_type: fidl::MethodType,
    },
}

impl ConfigOverrideRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_set_structured_config(
        self,
    ) -> Option<(
        String,
        Vec<fdomain_fuchsia_component_decl::ConfigOverride>,
        ConfigOverrideSetStructuredConfigResponder,
    )> {
        if let ConfigOverrideRequest::SetStructuredConfig { moniker, fields, responder } = self {
            Some((moniker, fields, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_unset_structured_config(
        self,
    ) -> Option<(String, ConfigOverrideUnsetStructuredConfigResponder)> {
        if let ConfigOverrideRequest::UnsetStructuredConfig { moniker, responder } = self {
            Some((moniker, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            ConfigOverrideRequest::SetStructuredConfig { .. } => "set_structured_config",
            ConfigOverrideRequest::UnsetStructuredConfig { .. } => "unset_structured_config",
            ConfigOverrideRequest::_UnknownMethod {
                method_type: fidl::MethodType::OneWay, ..
            } => "unknown one-way method",
            ConfigOverrideRequest::_UnknownMethod {
                method_type: fidl::MethodType::TwoWay, ..
            } => "unknown two-way method",
        }
    }
}

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

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

    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

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

impl ConfigOverrideControlHandle {}

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

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

impl fdomain_client::fidl::Responder for ConfigOverrideSetStructuredConfigResponder {
    type ControlHandle = ConfigOverrideControlHandle;

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

    fn send_raw(&self, mut result: Result<(), ConfigOverrideError>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
            fidl::encoding::EmptyStruct,
            ConfigOverrideError,
        >>(
            fidl::encoding::FlexibleResult::new(result),
            self.tx_id,
            0x2c6a138832d2e0ee,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

impl fdomain_client::fidl::Responder for ConfigOverrideUnsetStructuredConfigResponder {
    type ControlHandle = ConfigOverrideControlHandle;

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

    fn send_raw(&self, mut result: Result<(), ConfigOverrideError>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
            fidl::encoding::EmptyStruct,
            ConfigOverrideError,
        >>(
            fidl::encoding::FlexibleResult::new(result),
            self.tx_id,
            0x342ec7d2bef05552,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

impl fdomain_client::fidl::ProtocolMarker for CrashIntrospectMarker {
    type Proxy = CrashIntrospectProxy;
    type RequestStream = CrashIntrospectRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.sys2.CrashIntrospect";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for CrashIntrospectMarker {}
pub type CrashIntrospectFindComponentByThreadKoidResult =
    Result<ComponentCrashInfo, fdomain_fuchsia_component::Error>;

pub trait CrashIntrospectProxyInterface: Send + Sync {
    type FindComponentByThreadKoidResponseFut: std::future::Future<
            Output = Result<CrashIntrospectFindComponentByThreadKoidResult, fidl::Error>,
        > + Send;
    fn r#find_component_by_thread_koid(
        &self,
        thread_koid: u64,
    ) -> Self::FindComponentByThreadKoidResponseFut;
}

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

impl fdomain_client::fidl::Proxy for CrashIntrospectProxy {
    type Protocol = CrashIntrospectMarker;

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

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

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

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

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

    /// Given a thread koid, returns the information that was stored when the
    /// ELF runner observed a crash from that thread.
    ///
    /// The information for a crash is deleted when it is accessed or when 10
    /// minutes have passed, whichever comes first.
    ///
    /// If there is no information available on the given thread koid,
    /// `zx::Status::NOT_FOUND` is returned.
    pub fn r#find_component_by_thread_koid(
        &self,
        mut thread_koid: u64,
    ) -> fidl::client::QueryResponseFut<
        CrashIntrospectFindComponentByThreadKoidResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        CrashIntrospectProxyInterface::r#find_component_by_thread_koid(self, thread_koid)
    }
}

impl CrashIntrospectProxyInterface for CrashIntrospectProxy {
    type FindComponentByThreadKoidResponseFut = fidl::client::QueryResponseFut<
        CrashIntrospectFindComponentByThreadKoidResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#find_component_by_thread_koid(
        &self,
        mut thread_koid: u64,
    ) -> Self::FindComponentByThreadKoidResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<CrashIntrospectFindComponentByThreadKoidResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    CrashIntrospectFindComponentByThreadKoidResponse,
                    fdomain_fuchsia_component::Error,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                0x75d3ff081eca468d,
            >(_buf?)?;
            Ok(_response.map(|x| x.info))
        }
        self.client.send_query_and_decode::<
            CrashIntrospectFindComponentByThreadKoidRequest,
            CrashIntrospectFindComponentByThreadKoidResult,
        >(
            (thread_koid,),
            0x75d3ff081eca468d,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for CrashIntrospectRequestStream {
    type Protocol = CrashIntrospectMarker;
    type ControlHandle = CrashIntrospectControlHandle;

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

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

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

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

impl futures::Stream for CrashIntrospectRequestStream {
    type Item = Result<CrashIntrospectRequest, 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 CrashIntrospectRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(e))) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

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

                std::task::Poll::Ready(Some(match header.ordinal {
                0x75d3ff081eca468d => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(CrashIntrospectFindComponentByThreadKoidRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<CrashIntrospectFindComponentByThreadKoidRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = CrashIntrospectControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(CrashIntrospectRequest::FindComponentByThreadKoid {thread_koid: req.thread_koid,

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

/// When a thread from a component using the ELF runner crashes, the thread
/// koid along with other information is stored. This protocol can be used to
/// retrieve that stored information.
#[derive(Debug)]
pub enum CrashIntrospectRequest {
    /// Given a thread koid, returns the information that was stored when the
    /// ELF runner observed a crash from that thread.
    ///
    /// The information for a crash is deleted when it is accessed or when 10
    /// minutes have passed, whichever comes first.
    ///
    /// If there is no information available on the given thread koid,
    /// `zx::Status::NOT_FOUND` is returned.
    FindComponentByThreadKoid {
        thread_koid: u64,
        responder: CrashIntrospectFindComponentByThreadKoidResponder,
    },
}

impl CrashIntrospectRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_find_component_by_thread_koid(
        self,
    ) -> Option<(u64, CrashIntrospectFindComponentByThreadKoidResponder)> {
        if let CrashIntrospectRequest::FindComponentByThreadKoid { thread_koid, responder } = self {
            Some((thread_koid, responder))
        } else {
            None
        }
    }

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

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

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

    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

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

impl CrashIntrospectControlHandle {}

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

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

impl fdomain_client::fidl::Responder for CrashIntrospectFindComponentByThreadKoidResponder {
    type ControlHandle = CrashIntrospectControlHandle;

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

    fn send_raw(
        &self,
        mut result: Result<&ComponentCrashInfo, fdomain_fuchsia_component::Error>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            CrashIntrospectFindComponentByThreadKoidResponse,
            fdomain_fuchsia_component::Error,
        >>(
            result.map(|info| (info,)),
            self.tx_id,
            0x75d3ff081eca468d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fdomain_client::fidl::ProtocolMarker for InstanceIteratorMarker {
    type Proxy = InstanceIteratorProxy;
    type RequestStream = InstanceIteratorRequestStream;

    const DEBUG_NAME: &'static str = "(anonymous) InstanceIterator";
}

pub trait InstanceIteratorProxyInterface: Send + Sync {
    type NextResponseFut: std::future::Future<Output = Result<Vec<Instance>, fidl::Error>> + Send;
    fn r#next(&self) -> Self::NextResponseFut;
}

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

impl fdomain_client::fidl::Proxy for InstanceIteratorProxy {
    type Protocol = InstanceIteratorMarker;

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

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

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

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

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

    pub fn r#next(
        &self,
    ) -> fidl::client::QueryResponseFut<Vec<Instance>, fdomain_client::fidl::FDomainResourceDialect>
    {
        InstanceIteratorProxyInterface::r#next(self)
    }
}

impl InstanceIteratorProxyInterface for InstanceIteratorProxy {
    type NextResponseFut =
        fidl::client::QueryResponseFut<Vec<Instance>, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#next(&self) -> Self::NextResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<Instance>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                InstanceIteratorNextResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x3a4e3d52432a52ee,
            >(_buf?)?;
            Ok(_response.infos)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<Instance>>(
            (),
            0x3a4e3d52432a52ee,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for InstanceIteratorRequestStream {
    type Protocol = InstanceIteratorMarker;
    type ControlHandle = InstanceIteratorControlHandle;

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

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

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

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

impl futures::Stream for InstanceIteratorRequestStream {
    type Item = Result<InstanceIteratorRequest, 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 InstanceIteratorRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(e))) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

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

                std::task::Poll::Ready(Some(match header.ordinal {
                0x3a4e3d52432a52ee => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = InstanceIteratorControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(InstanceIteratorRequest::Next {
                        responder: InstanceIteratorNextResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <InstanceIteratorMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// An iterator over all instances in the realm
#[derive(Debug)]
pub enum InstanceIteratorRequest {
    Next { responder: InstanceIteratorNextResponder },
}

impl InstanceIteratorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_next(self) -> Option<(InstanceIteratorNextResponder)> {
        if let InstanceIteratorRequest::Next { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

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

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

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

    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

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

impl InstanceIteratorControlHandle {}

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

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

impl fdomain_client::fidl::Responder for InstanceIteratorNextResponder {
    type ControlHandle = InstanceIteratorControlHandle;

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

    fn send_raw(&self, mut infos: &[Instance]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<InstanceIteratorNextResponse>(
            (infos,),
            self.tx_id,
            0x3a4e3d52432a52ee,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fdomain_client::fidl::ProtocolMarker for LifecycleControllerMarker {
    type Proxy = LifecycleControllerProxy;
    type RequestStream = LifecycleControllerRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.sys2.LifecycleController";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for LifecycleControllerMarker {}
pub type LifecycleControllerStartInstanceResult = Result<(), StartError>;
pub type LifecycleControllerStartInstanceWithArgsResult = Result<(), StartError>;
pub type LifecycleControllerStopInstanceResult = Result<(), StopError>;
pub type LifecycleControllerResolveInstanceResult = Result<(), ResolveError>;
pub type LifecycleControllerUnresolveInstanceResult = Result<(), UnresolveError>;
pub type LifecycleControllerCreateInstanceResult = Result<(), CreateError>;
pub type LifecycleControllerDestroyInstanceResult = Result<(), DestroyError>;

pub trait LifecycleControllerProxyInterface: Send + Sync {
    type StartInstanceResponseFut: std::future::Future<Output = Result<LifecycleControllerStartInstanceResult, fidl::Error>>
        + Send;
    fn r#start_instance(
        &self,
        moniker: &str,
        binder: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_component::BinderMarker>,
    ) -> Self::StartInstanceResponseFut;
    type StartInstanceWithArgsResponseFut: std::future::Future<
            Output = Result<LifecycleControllerStartInstanceWithArgsResult, fidl::Error>,
        > + Send;
    fn r#start_instance_with_args(
        &self,
        moniker: &str,
        binder: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_component::BinderMarker>,
        args: fdomain_fuchsia_component::StartChildArgs,
    ) -> Self::StartInstanceWithArgsResponseFut;
    type StopInstanceResponseFut: std::future::Future<Output = Result<LifecycleControllerStopInstanceResult, fidl::Error>>
        + Send;
    fn r#stop_instance(&self, moniker: &str) -> Self::StopInstanceResponseFut;
    type ResolveInstanceResponseFut: std::future::Future<Output = Result<LifecycleControllerResolveInstanceResult, fidl::Error>>
        + Send;
    fn r#resolve_instance(&self, moniker: &str) -> Self::ResolveInstanceResponseFut;
    type UnresolveInstanceResponseFut: std::future::Future<
            Output = Result<LifecycleControllerUnresolveInstanceResult, fidl::Error>,
        > + Send;
    fn r#unresolve_instance(&self, moniker: &str) -> Self::UnresolveInstanceResponseFut;
    type CreateInstanceResponseFut: std::future::Future<Output = Result<LifecycleControllerCreateInstanceResult, fidl::Error>>
        + Send;
    fn r#create_instance(
        &self,
        parent_moniker: &str,
        collection: &fdomain_fuchsia_component_decl::CollectionRef,
        decl: &fdomain_fuchsia_component_decl::Child,
        args: fdomain_fuchsia_component::CreateChildArgs,
    ) -> Self::CreateInstanceResponseFut;
    type DestroyInstanceResponseFut: std::future::Future<Output = Result<LifecycleControllerDestroyInstanceResult, fidl::Error>>
        + Send;
    fn r#destroy_instance(
        &self,
        parent_moniker: &str,
        child: &fdomain_fuchsia_component_decl::ChildRef,
    ) -> Self::DestroyInstanceResponseFut;
}

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

impl fdomain_client::fidl::Proxy for LifecycleControllerProxy {
    type Protocol = LifecycleControllerMarker;

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

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

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

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

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

    /// Starts the instance identified by the given moniker. Relative
    /// monikers must start with "./".
    ///
    /// The client can pass in the server end of a channel
    /// for the fuchsia.component.Binder protocol. This protocol
    /// will notify the client when the instance has stopped.
    ///
    /// The function returns once the instance has been started. Calling
    /// StartInstance() when the instance is already running is a no-op, but
    /// it will connect the Binder channel if a valid handle is provided.
    pub fn r#start_instance(
        &self,
        mut moniker: &str,
        mut binder: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_component::BinderMarker>,
    ) -> fidl::client::QueryResponseFut<
        LifecycleControllerStartInstanceResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        LifecycleControllerProxyInterface::r#start_instance(self, moniker, binder)
    }

    pub fn r#start_instance_with_args(
        &self,
        mut moniker: &str,
        mut binder: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_component::BinderMarker>,
        mut args: fdomain_fuchsia_component::StartChildArgs,
    ) -> fidl::client::QueryResponseFut<
        LifecycleControllerStartInstanceWithArgsResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        LifecycleControllerProxyInterface::r#start_instance_with_args(self, moniker, binder, args)
    }

    /// Stops the instance identified by the given moniker. Relative
    /// monikers must start with "./".
    ///
    /// The function returns once the instance has been stopped.
    pub fn r#stop_instance(
        &self,
        mut moniker: &str,
    ) -> fidl::client::QueryResponseFut<
        LifecycleControllerStopInstanceResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        LifecycleControllerProxyInterface::r#stop_instance(self, moniker)
    }

    /// Resolves the instance identified by the given moniker. Relative
    /// monikers must start with "./".
    ///
    /// The function returns once the instance has been resolved.
    pub fn r#resolve_instance(
        &self,
        mut moniker: &str,
    ) -> fidl::client::QueryResponseFut<
        LifecycleControllerResolveInstanceResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        LifecycleControllerProxyInterface::r#resolve_instance(self, moniker)
    }

    /// Unresolves the component designated by the provided moniker. Relative
    /// monikers must start with "./".
    ///
    /// The function returns once the instance has been unresolved.
    pub fn r#unresolve_instance(
        &self,
        mut moniker: &str,
    ) -> fidl::client::QueryResponseFut<
        LifecycleControllerUnresolveInstanceResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        LifecycleControllerProxyInterface::r#unresolve_instance(self, moniker)
    }

    /// Creates a new child instance identified by the given moniker. Relative
    /// monikers must start with "./".
    ///
    /// The function returns once the child instance has been added to the topology.
    pub fn r#create_instance(
        &self,
        mut parent_moniker: &str,
        mut collection: &fdomain_fuchsia_component_decl::CollectionRef,
        mut decl: &fdomain_fuchsia_component_decl::Child,
        mut args: fdomain_fuchsia_component::CreateChildArgs,
    ) -> fidl::client::QueryResponseFut<
        LifecycleControllerCreateInstanceResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        LifecycleControllerProxyInterface::r#create_instance(
            self,
            parent_moniker,
            collection,
            decl,
            args,
        )
    }

    /// Destroys the instance identified by the given moniker. Relative
    /// monikers must start with "./".
    ///
    /// The function returns once the child instance no longer exists in the topology.
    pub fn r#destroy_instance(
        &self,
        mut parent_moniker: &str,
        mut child: &fdomain_fuchsia_component_decl::ChildRef,
    ) -> fidl::client::QueryResponseFut<
        LifecycleControllerDestroyInstanceResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        LifecycleControllerProxyInterface::r#destroy_instance(self, parent_moniker, child)
    }
}

impl LifecycleControllerProxyInterface for LifecycleControllerProxy {
    type StartInstanceResponseFut = fidl::client::QueryResponseFut<
        LifecycleControllerStartInstanceResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#start_instance(
        &self,
        mut moniker: &str,
        mut binder: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_component::BinderMarker>,
    ) -> Self::StartInstanceResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<LifecycleControllerStartInstanceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, StartError>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x13fcb422876384bf,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            LifecycleControllerStartInstanceRequest,
            LifecycleControllerStartInstanceResult,
        >(
            (moniker, binder,),
            0x13fcb422876384bf,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type StartInstanceWithArgsResponseFut = fidl::client::QueryResponseFut<
        LifecycleControllerStartInstanceWithArgsResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#start_instance_with_args(
        &self,
        mut moniker: &str,
        mut binder: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_component::BinderMarker>,
        mut args: fdomain_fuchsia_component::StartChildArgs,
    ) -> Self::StartInstanceWithArgsResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<LifecycleControllerStartInstanceWithArgsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, StartError>,
                fdomain_client::fidl::FDomainResourceDialect,
                0xd3b467436223e9,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            LifecycleControllerStartInstanceWithArgsRequest,
            LifecycleControllerStartInstanceWithArgsResult,
        >(
            (moniker, binder, &mut args,),
            0xd3b467436223e9,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type StopInstanceResponseFut = fidl::client::QueryResponseFut<
        LifecycleControllerStopInstanceResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#stop_instance(&self, mut moniker: &str) -> Self::StopInstanceResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<LifecycleControllerStopInstanceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, StopError>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x1362ba9d0e3caf36,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            LifecycleControllerStopInstanceRequest,
            LifecycleControllerStopInstanceResult,
        >(
            (moniker,),
            0x1362ba9d0e3caf36,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ResolveInstanceResponseFut = fidl::client::QueryResponseFut<
        LifecycleControllerResolveInstanceResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#resolve_instance(&self, mut moniker: &str) -> Self::ResolveInstanceResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<LifecycleControllerResolveInstanceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, ResolveError>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x426ab8dd53d8e737,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            LifecycleControllerResolveInstanceRequest,
            LifecycleControllerResolveInstanceResult,
        >(
            (moniker,),
            0x426ab8dd53d8e737,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type UnresolveInstanceResponseFut = fidl::client::QueryResponseFut<
        LifecycleControllerUnresolveInstanceResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#unresolve_instance(&self, mut moniker: &str) -> Self::UnresolveInstanceResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<LifecycleControllerUnresolveInstanceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, UnresolveError>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x18166a2aa798cb99,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            LifecycleControllerUnresolveInstanceRequest,
            LifecycleControllerUnresolveInstanceResult,
        >(
            (moniker,),
            0x18166a2aa798cb99,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type CreateInstanceResponseFut = fidl::client::QueryResponseFut<
        LifecycleControllerCreateInstanceResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#create_instance(
        &self,
        mut parent_moniker: &str,
        mut collection: &fdomain_fuchsia_component_decl::CollectionRef,
        mut decl: &fdomain_fuchsia_component_decl::Child,
        mut args: fdomain_fuchsia_component::CreateChildArgs,
    ) -> Self::CreateInstanceResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<LifecycleControllerCreateInstanceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, CreateError>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x48d17ae777e4f9,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            LifecycleControllerCreateInstanceRequest,
            LifecycleControllerCreateInstanceResult,
        >(
            (parent_moniker, collection, decl, &mut args,),
            0x48d17ae777e4f9,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type DestroyInstanceResponseFut = fidl::client::QueryResponseFut<
        LifecycleControllerDestroyInstanceResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#destroy_instance(
        &self,
        mut parent_moniker: &str,
        mut child: &fdomain_fuchsia_component_decl::ChildRef,
    ) -> Self::DestroyInstanceResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<LifecycleControllerDestroyInstanceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, DestroyError>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x27640ae5889d7443,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            LifecycleControllerDestroyInstanceRequest,
            LifecycleControllerDestroyInstanceResult,
        >(
            (parent_moniker, child,),
            0x27640ae5889d7443,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for LifecycleControllerRequestStream {
    type Protocol = LifecycleControllerMarker;
    type ControlHandle = LifecycleControllerControlHandle;

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

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

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

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

impl futures::Stream for LifecycleControllerRequestStream {
    type Item = Result<LifecycleControllerRequest, 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 LifecycleControllerRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(e))) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

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

                std::task::Poll::Ready(Some(match header.ordinal {
                0x13fcb422876384bf => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(LifecycleControllerStartInstanceRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<LifecycleControllerStartInstanceRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = LifecycleControllerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(LifecycleControllerRequest::StartInstance {moniker: req.moniker,
binder: req.binder,

                        responder: LifecycleControllerStartInstanceResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0xd3b467436223e9 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(LifecycleControllerStartInstanceWithArgsRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<LifecycleControllerStartInstanceWithArgsRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = LifecycleControllerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(LifecycleControllerRequest::StartInstanceWithArgs {moniker: req.moniker,
binder: req.binder,
args: req.args,

                        responder: LifecycleControllerStartInstanceWithArgsResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x1362ba9d0e3caf36 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(LifecycleControllerStopInstanceRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<LifecycleControllerStopInstanceRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = LifecycleControllerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(LifecycleControllerRequest::StopInstance {moniker: req.moniker,

                        responder: LifecycleControllerStopInstanceResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x426ab8dd53d8e737 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(LifecycleControllerResolveInstanceRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<LifecycleControllerResolveInstanceRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = LifecycleControllerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(LifecycleControllerRequest::ResolveInstance {moniker: req.moniker,

                        responder: LifecycleControllerResolveInstanceResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x18166a2aa798cb99 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(LifecycleControllerUnresolveInstanceRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<LifecycleControllerUnresolveInstanceRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = LifecycleControllerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(LifecycleControllerRequest::UnresolveInstance {moniker: req.moniker,

                        responder: LifecycleControllerUnresolveInstanceResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x48d17ae777e4f9 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(LifecycleControllerCreateInstanceRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<LifecycleControllerCreateInstanceRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = LifecycleControllerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(LifecycleControllerRequest::CreateInstance {parent_moniker: req.parent_moniker,
collection: req.collection,
decl: req.decl,
args: req.args,

                        responder: LifecycleControllerCreateInstanceResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x27640ae5889d7443 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(LifecycleControllerDestroyInstanceRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<LifecycleControllerDestroyInstanceRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = LifecycleControllerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(LifecycleControllerRequest::DestroyInstance {parent_moniker: req.parent_moniker,
child: req.child,

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

/// Mutates the component instance state in a realm.
#[derive(Debug)]
pub enum LifecycleControllerRequest {
    /// Starts the instance identified by the given moniker. Relative
    /// monikers must start with "./".
    ///
    /// The client can pass in the server end of a channel
    /// for the fuchsia.component.Binder protocol. This protocol
    /// will notify the client when the instance has stopped.
    ///
    /// The function returns once the instance has been started. Calling
    /// StartInstance() when the instance is already running is a no-op, but
    /// it will connect the Binder channel if a valid handle is provided.
    StartInstance {
        moniker: String,
        binder: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_component::BinderMarker>,
        responder: LifecycleControllerStartInstanceResponder,
    },
    StartInstanceWithArgs {
        moniker: String,
        binder: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_component::BinderMarker>,
        args: fdomain_fuchsia_component::StartChildArgs,
        responder: LifecycleControllerStartInstanceWithArgsResponder,
    },
    /// Stops the instance identified by the given moniker. Relative
    /// monikers must start with "./".
    ///
    /// The function returns once the instance has been stopped.
    StopInstance { moniker: String, responder: LifecycleControllerStopInstanceResponder },
    /// Resolves the instance identified by the given moniker. Relative
    /// monikers must start with "./".
    ///
    /// The function returns once the instance has been resolved.
    ResolveInstance { moniker: String, responder: LifecycleControllerResolveInstanceResponder },
    /// Unresolves the component designated by the provided moniker. Relative
    /// monikers must start with "./".
    ///
    /// The function returns once the instance has been unresolved.
    UnresolveInstance { moniker: String, responder: LifecycleControllerUnresolveInstanceResponder },
    /// Creates a new child instance identified by the given moniker. Relative
    /// monikers must start with "./".
    ///
    /// The function returns once the child instance has been added to the topology.
    CreateInstance {
        parent_moniker: String,
        collection: fdomain_fuchsia_component_decl::CollectionRef,
        decl: fdomain_fuchsia_component_decl::Child,
        args: fdomain_fuchsia_component::CreateChildArgs,
        responder: LifecycleControllerCreateInstanceResponder,
    },
    /// Destroys the instance identified by the given moniker. Relative
    /// monikers must start with "./".
    ///
    /// The function returns once the child instance no longer exists in the topology.
    DestroyInstance {
        parent_moniker: String,
        child: fdomain_fuchsia_component_decl::ChildRef,
        responder: LifecycleControllerDestroyInstanceResponder,
    },
}

impl LifecycleControllerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_start_instance(
        self,
    ) -> Option<(
        String,
        fdomain_client::fidl::ServerEnd<fdomain_fuchsia_component::BinderMarker>,
        LifecycleControllerStartInstanceResponder,
    )> {
        if let LifecycleControllerRequest::StartInstance { moniker, binder, responder } = self {
            Some((moniker, binder, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_start_instance_with_args(
        self,
    ) -> Option<(
        String,
        fdomain_client::fidl::ServerEnd<fdomain_fuchsia_component::BinderMarker>,
        fdomain_fuchsia_component::StartChildArgs,
        LifecycleControllerStartInstanceWithArgsResponder,
    )> {
        if let LifecycleControllerRequest::StartInstanceWithArgs {
            moniker,
            binder,
            args,
            responder,
        } = self
        {
            Some((moniker, binder, args, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_stop_instance(self) -> Option<(String, LifecycleControllerStopInstanceResponder)> {
        if let LifecycleControllerRequest::StopInstance { moniker, responder } = self {
            Some((moniker, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_resolve_instance(
        self,
    ) -> Option<(String, LifecycleControllerResolveInstanceResponder)> {
        if let LifecycleControllerRequest::ResolveInstance { moniker, responder } = self {
            Some((moniker, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_unresolve_instance(
        self,
    ) -> Option<(String, LifecycleControllerUnresolveInstanceResponder)> {
        if let LifecycleControllerRequest::UnresolveInstance { moniker, responder } = self {
            Some((moniker, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_create_instance(
        self,
    ) -> Option<(
        String,
        fdomain_fuchsia_component_decl::CollectionRef,
        fdomain_fuchsia_component_decl::Child,
        fdomain_fuchsia_component::CreateChildArgs,
        LifecycleControllerCreateInstanceResponder,
    )> {
        if let LifecycleControllerRequest::CreateInstance {
            parent_moniker,
            collection,
            decl,
            args,
            responder,
        } = self
        {
            Some((parent_moniker, collection, decl, args, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_destroy_instance(
        self,
    ) -> Option<(
        String,
        fdomain_fuchsia_component_decl::ChildRef,
        LifecycleControllerDestroyInstanceResponder,
    )> {
        if let LifecycleControllerRequest::DestroyInstance { parent_moniker, child, responder } =
            self
        {
            Some((parent_moniker, child, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            LifecycleControllerRequest::StartInstance { .. } => "start_instance",
            LifecycleControllerRequest::StartInstanceWithArgs { .. } => "start_instance_with_args",
            LifecycleControllerRequest::StopInstance { .. } => "stop_instance",
            LifecycleControllerRequest::ResolveInstance { .. } => "resolve_instance",
            LifecycleControllerRequest::UnresolveInstance { .. } => "unresolve_instance",
            LifecycleControllerRequest::CreateInstance { .. } => "create_instance",
            LifecycleControllerRequest::DestroyInstance { .. } => "destroy_instance",
        }
    }
}

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

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

    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

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

impl LifecycleControllerControlHandle {}

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

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

impl fdomain_client::fidl::Responder for LifecycleControllerStartInstanceResponder {
    type ControlHandle = LifecycleControllerControlHandle;

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

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

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

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

impl fdomain_client::fidl::Responder for LifecycleControllerStartInstanceWithArgsResponder {
    type ControlHandle = LifecycleControllerControlHandle;

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

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

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

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

impl fdomain_client::fidl::Responder for LifecycleControllerStopInstanceResponder {
    type ControlHandle = LifecycleControllerControlHandle;

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

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

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

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

impl fdomain_client::fidl::Responder for LifecycleControllerResolveInstanceResponder {
    type ControlHandle = LifecycleControllerControlHandle;

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

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

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

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

impl fdomain_client::fidl::Responder for LifecycleControllerUnresolveInstanceResponder {
    type ControlHandle = LifecycleControllerControlHandle;

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

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

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

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

impl fdomain_client::fidl::Responder for LifecycleControllerCreateInstanceResponder {
    type ControlHandle = LifecycleControllerControlHandle;

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

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

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

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

impl fdomain_client::fidl::Responder for LifecycleControllerDestroyInstanceResponder {
    type ControlHandle = LifecycleControllerControlHandle;

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

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

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

impl fdomain_client::fidl::ProtocolMarker for ManifestBytesIteratorMarker {
    type Proxy = ManifestBytesIteratorProxy;
    type RequestStream = ManifestBytesIteratorRequestStream;

    const DEBUG_NAME: &'static str = "(anonymous) ManifestBytesIterator";
}

pub trait ManifestBytesIteratorProxyInterface: Send + Sync {
    type NextResponseFut: std::future::Future<Output = Result<Vec<u8>, fidl::Error>> + Send;
    fn r#next(&self) -> Self::NextResponseFut;
}

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

impl fdomain_client::fidl::Proxy for ManifestBytesIteratorProxy {
    type Protocol = ManifestBytesIteratorMarker;

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

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

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

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

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

    pub fn r#next(
        &self,
    ) -> fidl::client::QueryResponseFut<Vec<u8>, fdomain_client::fidl::FDomainResourceDialect> {
        ManifestBytesIteratorProxyInterface::r#next(self)
    }
}

impl ManifestBytesIteratorProxyInterface for ManifestBytesIteratorProxy {
    type NextResponseFut =
        fidl::client::QueryResponseFut<Vec<u8>, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#next(&self) -> Self::NextResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<u8>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ManifestBytesIteratorNextResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x4be4659549b15500,
            >(_buf?)?;
            Ok(_response.infos)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<u8>>(
            (),
            0x4be4659549b15500,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for ManifestBytesIteratorRequestStream {
    type Protocol = ManifestBytesIteratorMarker;
    type ControlHandle = ManifestBytesIteratorControlHandle;

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

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

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

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

impl futures::Stream for ManifestBytesIteratorRequestStream {
    type Item = Result<ManifestBytesIteratorRequest, 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 ManifestBytesIteratorRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(e))) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

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

                std::task::Poll::Ready(Some(match header.ordinal {
                0x4be4659549b15500 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = ManifestBytesIteratorControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(ManifestBytesIteratorRequest::Next {
                        responder: ManifestBytesIteratorNextResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <ManifestBytesIteratorMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// An iterator over the bytes of an instance's manifest
#[derive(Debug)]
pub enum ManifestBytesIteratorRequest {
    Next { responder: ManifestBytesIteratorNextResponder },
}

impl ManifestBytesIteratorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_next(self) -> Option<(ManifestBytesIteratorNextResponder)> {
        if let ManifestBytesIteratorRequest::Next { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

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

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

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

    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

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

impl ManifestBytesIteratorControlHandle {}

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

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

impl fdomain_client::fidl::Responder for ManifestBytesIteratorNextResponder {
    type ControlHandle = ManifestBytesIteratorControlHandle;

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

    fn send_raw(&self, mut infos: &[u8]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<ManifestBytesIteratorNextResponse>(
            (infos,),
            self.tx_id,
            0x4be4659549b15500,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fdomain_client::fidl::ProtocolMarker for RealmExplorerMarker {
    type Proxy = RealmExplorerProxy;
    type RequestStream = RealmExplorerRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.sys2.RealmExplorer";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for RealmExplorerMarker {}

pub trait RealmExplorerProxyInterface: Send + Sync {}

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

impl fdomain_client::fidl::Proxy for RealmExplorerProxy {
    type Protocol = RealmExplorerMarker;

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

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

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

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

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

impl RealmExplorerProxyInterface for RealmExplorerProxy {}

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for RealmExplorerRequestStream {
    type Protocol = RealmExplorerMarker;
    type ControlHandle = RealmExplorerControlHandle;

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

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

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

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

impl futures::Stream for RealmExplorerRequestStream {
    type Item = Result<RealmExplorerRequest, 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 RealmExplorerRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(e))) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

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

                std::task::Poll::Ready(Some(match header.ordinal {
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <RealmExplorerMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// Offers basic introspection into component instances under a realm.
#[derive(Debug)]
pub enum RealmExplorerRequest {}

impl RealmExplorerRequest {
    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {}
    }
}

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

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

    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

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

impl RealmExplorerControlHandle {}

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

impl fdomain_client::fidl::ProtocolMarker for RealmQueryMarker {
    type Proxy = RealmQueryProxy;
    type RequestStream = RealmQueryRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.sys2.RealmQuery";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for RealmQueryMarker {}
pub type RealmQueryGetInstanceResult = Result<Instance, GetInstanceError>;
pub type RealmQueryGetResolvedDeclarationResult =
    Result<fdomain_client::fidl::ClientEnd<ManifestBytesIteratorMarker>, GetDeclarationError>;
pub type RealmQueryResolveDeclarationResult =
    Result<fdomain_client::fidl::ClientEnd<ManifestBytesIteratorMarker>, GetDeclarationError>;
pub type RealmQueryGetStructuredConfigResult =
    Result<fdomain_fuchsia_component_decl::ResolvedConfig, GetStructuredConfigError>;
pub type RealmQueryGetAllInstancesResult =
    Result<fdomain_client::fidl::ClientEnd<InstanceIteratorMarker>, GetAllInstancesError>;
pub type RealmQueryConstructNamespaceResult =
    Result<Vec<fdomain_fuchsia_component_runner::ComponentNamespaceEntry>, ConstructNamespaceError>;
pub type RealmQueryOpenDirectoryResult = Result<(), OpenError>;
pub type RealmQueryConnectToStorageAdminResult = Result<(), ConnectToStorageAdminError>;

pub trait RealmQueryProxyInterface: Send + Sync {
    type GetInstanceResponseFut: std::future::Future<Output = Result<RealmQueryGetInstanceResult, fidl::Error>>
        + Send;
    fn r#get_instance(&self, moniker: &str) -> Self::GetInstanceResponseFut;
    type GetResolvedDeclarationResponseFut: std::future::Future<Output = Result<RealmQueryGetResolvedDeclarationResult, fidl::Error>>
        + Send;
    fn r#get_resolved_declaration(&self, moniker: &str) -> Self::GetResolvedDeclarationResponseFut;
    type ResolveDeclarationResponseFut: std::future::Future<Output = Result<RealmQueryResolveDeclarationResult, fidl::Error>>
        + Send;
    fn r#resolve_declaration(
        &self,
        parent: &str,
        child_location: &ChildLocation,
        url: &str,
    ) -> Self::ResolveDeclarationResponseFut;
    type GetStructuredConfigResponseFut: std::future::Future<Output = Result<RealmQueryGetStructuredConfigResult, fidl::Error>>
        + Send;
    fn r#get_structured_config(&self, moniker: &str) -> Self::GetStructuredConfigResponseFut;
    type GetAllInstancesResponseFut: std::future::Future<Output = Result<RealmQueryGetAllInstancesResult, fidl::Error>>
        + Send;
    fn r#get_all_instances(&self) -> Self::GetAllInstancesResponseFut;
    type ConstructNamespaceResponseFut: std::future::Future<Output = Result<RealmQueryConstructNamespaceResult, fidl::Error>>
        + Send;
    fn r#construct_namespace(&self, moniker: &str) -> Self::ConstructNamespaceResponseFut;
    type OpenDirectoryResponseFut: std::future::Future<Output = Result<RealmQueryOpenDirectoryResult, fidl::Error>>
        + Send;
    fn r#open_directory(
        &self,
        moniker: &str,
        dir_type: OpenDirType,
        object: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::DirectoryMarker>,
    ) -> Self::OpenDirectoryResponseFut;
    type ConnectToStorageAdminResponseFut: std::future::Future<Output = Result<RealmQueryConnectToStorageAdminResult, fidl::Error>>
        + Send;
    fn r#connect_to_storage_admin(
        &self,
        moniker: &str,
        storage_name: &str,
        server_end: fdomain_client::fidl::ServerEnd<StorageAdminMarker>,
    ) -> Self::ConnectToStorageAdminResponseFut;
}

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

impl fdomain_client::fidl::Proxy for RealmQueryProxy {
    type Protocol = RealmQueryMarker;

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

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

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

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

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

    /// Gets an instance identified by its moniker.
    pub fn r#get_instance(
        &self,
        mut moniker: &str,
    ) -> fidl::client::QueryResponseFut<
        RealmQueryGetInstanceResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        RealmQueryProxyInterface::r#get_instance(self, moniker)
    }

    /// Gets the manifest of an instance identified by its moniker.
    ///
    /// The manifest is encoded in its standalone persistable format per RFC-0120 and
    /// is sent across using an iterator. Some manifests are too large to send over a
    /// Zircon channel and we can't use a VMO because we need an approach that is
    /// compatible with overnet.
    pub fn r#get_resolved_declaration(
        &self,
        mut moniker: &str,
    ) -> fidl::client::QueryResponseFut<
        RealmQueryGetResolvedDeclarationResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        RealmQueryProxyInterface::r#get_resolved_declaration(self, moniker)
    }

    /// Gets the manifest of a component URL as if it were a child of the specified parent
    /// without actually creating or starting that component.
    ///
    /// The manifest is encoded in its standalone persistable format per RFC-0120 and
    /// is sent across using an iterator. Some manifests are too large to send over a
    /// Zircon channel and we can't use a VMO because we need an approach that is
    /// compatible with overnet.
    pub fn r#resolve_declaration(
        &self,
        mut parent: &str,
        mut child_location: &ChildLocation,
        mut url: &str,
    ) -> fidl::client::QueryResponseFut<
        RealmQueryResolveDeclarationResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        RealmQueryProxyInterface::r#resolve_declaration(self, parent, child_location, url)
    }

    /// Gets the structured config of an instance identified by its moniker.
    pub fn r#get_structured_config(
        &self,
        mut moniker: &str,
    ) -> fidl::client::QueryResponseFut<
        RealmQueryGetStructuredConfigResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        RealmQueryProxyInterface::r#get_structured_config(self, moniker)
    }

    /// Returns an iterator over all component instances in this realm and instances within resolved
    /// children, recursively. Unresolved child components will be included in this list, but
    /// children of unresolved children will not be.
    pub fn r#get_all_instances(
        &self,
    ) -> fidl::client::QueryResponseFut<
        RealmQueryGetAllInstancesResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        RealmQueryProxyInterface::r#get_all_instances(self)
    }

    /// Constructs the namespace of an instance as determined by its use declarations.
    /// This is usually identical to what would be given to the component's runner on
    /// component start time, unless extended by
    /// `fuchsia.component/StartChildArgs.namespace_entries`.
    pub fn r#construct_namespace(
        &self,
        mut moniker: &str,
    ) -> fidl::client::QueryResponseFut<
        RealmQueryConstructNamespaceResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        RealmQueryProxyInterface::r#construct_namespace(self, moniker)
    }

    /// Opens the specified directory in an instance.
    pub fn r#open_directory(
        &self,
        mut moniker: &str,
        mut dir_type: OpenDirType,
        mut object: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::DirectoryMarker>,
    ) -> fidl::client::QueryResponseFut<
        RealmQueryOpenDirectoryResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        RealmQueryProxyInterface::r#open_directory(self, moniker, dir_type, object)
    }

    /// Connects to the StorageAdmin protocol of a storage declared by an instance.
    pub fn r#connect_to_storage_admin(
        &self,
        mut moniker: &str,
        mut storage_name: &str,
        mut server_end: fdomain_client::fidl::ServerEnd<StorageAdminMarker>,
    ) -> fidl::client::QueryResponseFut<
        RealmQueryConnectToStorageAdminResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        RealmQueryProxyInterface::r#connect_to_storage_admin(
            self,
            moniker,
            storage_name,
            server_end,
        )
    }
}

impl RealmQueryProxyInterface for RealmQueryProxy {
    type GetInstanceResponseFut = fidl::client::QueryResponseFut<
        RealmQueryGetInstanceResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_instance(&self, mut moniker: &str) -> Self::GetInstanceResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RealmQueryGetInstanceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<RealmQueryGetInstanceResponse, GetInstanceError>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x3496ca1e5a0c13a8,
            >(_buf?)?;
            Ok(_response.map(|x| x.instance))
        }
        self.client
            .send_query_and_decode::<RealmQueryGetInstanceRequest, RealmQueryGetInstanceResult>(
                (moniker,),
                0x3496ca1e5a0c13a8,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetResolvedDeclarationResponseFut = fidl::client::QueryResponseFut<
        RealmQueryGetResolvedDeclarationResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_resolved_declaration(
        &self,
        mut moniker: &str,
    ) -> Self::GetResolvedDeclarationResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RealmQueryGetResolvedDeclarationResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    RealmQueryGetResolvedDeclarationResponse,
                    GetDeclarationError,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                0x31a493d284a0bc1f,
            >(_buf?)?;
            Ok(_response.map(|x| x.iterator))
        }
        self.client.send_query_and_decode::<
            RealmQueryGetResolvedDeclarationRequest,
            RealmQueryGetResolvedDeclarationResult,
        >(
            (moniker,),
            0x31a493d284a0bc1f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ResolveDeclarationResponseFut = fidl::client::QueryResponseFut<
        RealmQueryResolveDeclarationResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#resolve_declaration(
        &self,
        mut parent: &str,
        mut child_location: &ChildLocation,
        mut url: &str,
    ) -> Self::ResolveDeclarationResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RealmQueryResolveDeclarationResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    RealmQueryResolveDeclarationResponse,
                    GetDeclarationError,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                0x1ab1adf2a87d962d,
            >(_buf?)?;
            Ok(_response.map(|x| x.iterator))
        }
        self.client.send_query_and_decode::<
            RealmQueryResolveDeclarationRequest,
            RealmQueryResolveDeclarationResult,
        >(
            (parent, child_location, url,),
            0x1ab1adf2a87d962d,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetStructuredConfigResponseFut = fidl::client::QueryResponseFut<
        RealmQueryGetStructuredConfigResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_structured_config(&self, mut moniker: &str) -> Self::GetStructuredConfigResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RealmQueryGetStructuredConfigResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    RealmQueryGetStructuredConfigResponse,
                    GetStructuredConfigError,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                0x16f88f6735bd204,
            >(_buf?)?;
            Ok(_response.map(|x| x.config))
        }
        self.client.send_query_and_decode::<
            RealmQueryGetStructuredConfigRequest,
            RealmQueryGetStructuredConfigResult,
        >(
            (moniker,),
            0x16f88f6735bd204,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetAllInstancesResponseFut = fidl::client::QueryResponseFut<
        RealmQueryGetAllInstancesResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_all_instances(&self) -> Self::GetAllInstancesResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RealmQueryGetAllInstancesResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<RealmQueryGetAllInstancesResponse, GetAllInstancesError>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x7b5a8775d30cad47,
            >(_buf?)?;
            Ok(_response.map(|x| x.iterator))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, RealmQueryGetAllInstancesResult>(
                (),
                0x7b5a8775d30cad47,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type ConstructNamespaceResponseFut = fidl::client::QueryResponseFut<
        RealmQueryConstructNamespaceResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#construct_namespace(&self, mut moniker: &str) -> Self::ConstructNamespaceResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RealmQueryConstructNamespaceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    RealmQueryConstructNamespaceResponse,
                    ConstructNamespaceError,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                0x5ecb29c02c488eeb,
            >(_buf?)?;
            Ok(_response.map(|x| x.namespace))
        }
        self.client.send_query_and_decode::<
            RealmQueryConstructNamespaceRequest,
            RealmQueryConstructNamespaceResult,
        >(
            (moniker,),
            0x5ecb29c02c488eeb,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type OpenDirectoryResponseFut = fidl::client::QueryResponseFut<
        RealmQueryOpenDirectoryResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#open_directory(
        &self,
        mut moniker: &str,
        mut dir_type: OpenDirType,
        mut object: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::DirectoryMarker>,
    ) -> Self::OpenDirectoryResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RealmQueryOpenDirectoryResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, OpenError>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x333d68f1deecec85,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<RealmQueryOpenDirectoryRequest, RealmQueryOpenDirectoryResult>(
                (moniker, dir_type, object),
                0x333d68f1deecec85,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type ConnectToStorageAdminResponseFut = fidl::client::QueryResponseFut<
        RealmQueryConnectToStorageAdminResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#connect_to_storage_admin(
        &self,
        mut moniker: &str,
        mut storage_name: &str,
        mut server_end: fdomain_client::fidl::ServerEnd<StorageAdminMarker>,
    ) -> Self::ConnectToStorageAdminResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RealmQueryConnectToStorageAdminResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, ConnectToStorageAdminError>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x7807e6b4f623ace,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            RealmQueryConnectToStorageAdminRequest,
            RealmQueryConnectToStorageAdminResult,
        >(
            (moniker, storage_name, server_end,),
            0x7807e6b4f623ace,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for RealmQueryRequestStream {
    type Protocol = RealmQueryMarker;
    type ControlHandle = RealmQueryControlHandle;

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

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

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

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

impl futures::Stream for RealmQueryRequestStream {
    type Item = Result<RealmQueryRequest, 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 RealmQueryRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(e))) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x3496ca1e5a0c13a8 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RealmQueryGetInstanceRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<RealmQueryGetInstanceRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RealmQueryControlHandle { inner: this.inner.clone() };
                        Ok(RealmQueryRequest::GetInstance {
                            moniker: req.moniker,

                            responder: RealmQueryGetInstanceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x31a493d284a0bc1f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RealmQueryGetResolvedDeclarationRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<RealmQueryGetResolvedDeclarationRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RealmQueryControlHandle { inner: this.inner.clone() };
                        Ok(RealmQueryRequest::GetResolvedDeclaration {
                            moniker: req.moniker,

                            responder: RealmQueryGetResolvedDeclarationResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1ab1adf2a87d962d => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RealmQueryResolveDeclarationRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<RealmQueryResolveDeclarationRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RealmQueryControlHandle { inner: this.inner.clone() };
                        Ok(RealmQueryRequest::ResolveDeclaration {
                            parent: req.parent,
                            child_location: req.child_location,
                            url: req.url,

                            responder: RealmQueryResolveDeclarationResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x16f88f6735bd204 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RealmQueryGetStructuredConfigRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<RealmQueryGetStructuredConfigRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RealmQueryControlHandle { inner: this.inner.clone() };
                        Ok(RealmQueryRequest::GetStructuredConfig {
                            moniker: req.moniker,

                            responder: RealmQueryGetStructuredConfigResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7b5a8775d30cad47 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RealmQueryControlHandle { inner: this.inner.clone() };
                        Ok(RealmQueryRequest::GetAllInstances {
                            responder: RealmQueryGetAllInstancesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5ecb29c02c488eeb => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RealmQueryConstructNamespaceRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<RealmQueryConstructNamespaceRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RealmQueryControlHandle { inner: this.inner.clone() };
                        Ok(RealmQueryRequest::ConstructNamespace {
                            moniker: req.moniker,

                            responder: RealmQueryConstructNamespaceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x333d68f1deecec85 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RealmQueryOpenDirectoryRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<RealmQueryOpenDirectoryRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RealmQueryControlHandle { inner: this.inner.clone() };
                        Ok(RealmQueryRequest::OpenDirectory {
                            moniker: req.moniker,
                            dir_type: req.dir_type,
                            object: req.object,

                            responder: RealmQueryOpenDirectoryResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7807e6b4f623ace => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RealmQueryConnectToStorageAdminRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<RealmQueryConnectToStorageAdminRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RealmQueryControlHandle { inner: this.inner.clone() };
                        Ok(RealmQueryRequest::ConnectToStorageAdmin {
                            moniker: req.moniker,
                            storage_name: req.storage_name,
                            server_end: req.server_end,

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

/// Offers detailed introspection into component instances under a realm.
#[derive(Debug)]
pub enum RealmQueryRequest {
    /// Gets an instance identified by its moniker.
    GetInstance { moniker: String, responder: RealmQueryGetInstanceResponder },
    /// Gets the manifest of an instance identified by its moniker.
    ///
    /// The manifest is encoded in its standalone persistable format per RFC-0120 and
    /// is sent across using an iterator. Some manifests are too large to send over a
    /// Zircon channel and we can't use a VMO because we need an approach that is
    /// compatible with overnet.
    GetResolvedDeclaration { moniker: String, responder: RealmQueryGetResolvedDeclarationResponder },
    /// Gets the manifest of a component URL as if it were a child of the specified parent
    /// without actually creating or starting that component.
    ///
    /// The manifest is encoded in its standalone persistable format per RFC-0120 and
    /// is sent across using an iterator. Some manifests are too large to send over a
    /// Zircon channel and we can't use a VMO because we need an approach that is
    /// compatible with overnet.
    ResolveDeclaration {
        parent: String,
        child_location: ChildLocation,
        url: String,
        responder: RealmQueryResolveDeclarationResponder,
    },
    /// Gets the structured config of an instance identified by its moniker.
    GetStructuredConfig { moniker: String, responder: RealmQueryGetStructuredConfigResponder },
    /// Returns an iterator over all component instances in this realm and instances within resolved
    /// children, recursively. Unresolved child components will be included in this list, but
    /// children of unresolved children will not be.
    GetAllInstances { responder: RealmQueryGetAllInstancesResponder },
    /// Constructs the namespace of an instance as determined by its use declarations.
    /// This is usually identical to what would be given to the component's runner on
    /// component start time, unless extended by
    /// `fuchsia.component/StartChildArgs.namespace_entries`.
    ConstructNamespace { moniker: String, responder: RealmQueryConstructNamespaceResponder },
    /// Opens the specified directory in an instance.
    OpenDirectory {
        moniker: String,
        dir_type: OpenDirType,
        object: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::DirectoryMarker>,
        responder: RealmQueryOpenDirectoryResponder,
    },
    /// Connects to the StorageAdmin protocol of a storage declared by an instance.
    ConnectToStorageAdmin {
        moniker: String,
        storage_name: String,
        server_end: fdomain_client::fidl::ServerEnd<StorageAdminMarker>,
        responder: RealmQueryConnectToStorageAdminResponder,
    },
}

impl RealmQueryRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_instance(self) -> Option<(String, RealmQueryGetInstanceResponder)> {
        if let RealmQueryRequest::GetInstance { moniker, responder } = self {
            Some((moniker, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_resolved_declaration(
        self,
    ) -> Option<(String, RealmQueryGetResolvedDeclarationResponder)> {
        if let RealmQueryRequest::GetResolvedDeclaration { moniker, responder } = self {
            Some((moniker, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_resolve_declaration(
        self,
    ) -> Option<(String, ChildLocation, String, RealmQueryResolveDeclarationResponder)> {
        if let RealmQueryRequest::ResolveDeclaration { parent, child_location, url, responder } =
            self
        {
            Some((parent, child_location, url, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_structured_config(
        self,
    ) -> Option<(String, RealmQueryGetStructuredConfigResponder)> {
        if let RealmQueryRequest::GetStructuredConfig { moniker, responder } = self {
            Some((moniker, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_all_instances(self) -> Option<(RealmQueryGetAllInstancesResponder)> {
        if let RealmQueryRequest::GetAllInstances { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_construct_namespace(
        self,
    ) -> Option<(String, RealmQueryConstructNamespaceResponder)> {
        if let RealmQueryRequest::ConstructNamespace { moniker, responder } = self {
            Some((moniker, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_open_directory(
        self,
    ) -> Option<(
        String,
        OpenDirType,
        fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::DirectoryMarker>,
        RealmQueryOpenDirectoryResponder,
    )> {
        if let RealmQueryRequest::OpenDirectory { moniker, dir_type, object, responder } = self {
            Some((moniker, dir_type, object, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_connect_to_storage_admin(
        self,
    ) -> Option<(
        String,
        String,
        fdomain_client::fidl::ServerEnd<StorageAdminMarker>,
        RealmQueryConnectToStorageAdminResponder,
    )> {
        if let RealmQueryRequest::ConnectToStorageAdmin {
            moniker,
            storage_name,
            server_end,
            responder,
        } = self
        {
            Some((moniker, storage_name, server_end, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            RealmQueryRequest::GetInstance { .. } => "get_instance",
            RealmQueryRequest::GetResolvedDeclaration { .. } => "get_resolved_declaration",
            RealmQueryRequest::ResolveDeclaration { .. } => "resolve_declaration",
            RealmQueryRequest::GetStructuredConfig { .. } => "get_structured_config",
            RealmQueryRequest::GetAllInstances { .. } => "get_all_instances",
            RealmQueryRequest::ConstructNamespace { .. } => "construct_namespace",
            RealmQueryRequest::OpenDirectory { .. } => "open_directory",
            RealmQueryRequest::ConnectToStorageAdmin { .. } => "connect_to_storage_admin",
        }
    }
}

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

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

    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

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

impl RealmQueryControlHandle {}

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

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

impl fdomain_client::fidl::Responder for RealmQueryGetInstanceResponder {
    type ControlHandle = RealmQueryControlHandle;

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

    fn send_raw(&self, mut result: Result<&Instance, GetInstanceError>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            RealmQueryGetInstanceResponse,
            GetInstanceError,
        >>(
            result.map(|instance| (instance,)),
            self.tx_id,
            0x3496ca1e5a0c13a8,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

impl fdomain_client::fidl::Responder for RealmQueryGetResolvedDeclarationResponder {
    type ControlHandle = RealmQueryControlHandle;

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

    fn send_raw(
        &self,
        mut result: Result<
            fdomain_client::fidl::ClientEnd<ManifestBytesIteratorMarker>,
            GetDeclarationError,
        >,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            RealmQueryGetResolvedDeclarationResponse,
            GetDeclarationError,
        >>(
            result.map(|iterator| (iterator,)),
            self.tx_id,
            0x31a493d284a0bc1f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

impl fdomain_client::fidl::Responder for RealmQueryResolveDeclarationResponder {
    type ControlHandle = RealmQueryControlHandle;

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

    fn send_raw(
        &self,
        mut result: Result<
            fdomain_client::fidl::ClientEnd<ManifestBytesIteratorMarker>,
            GetDeclarationError,
        >,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            RealmQueryResolveDeclarationResponse,
            GetDeclarationError,
        >>(
            result.map(|iterator| (iterator,)),
            self.tx_id,
            0x1ab1adf2a87d962d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

impl fdomain_client::fidl::Responder for RealmQueryGetStructuredConfigResponder {
    type ControlHandle = RealmQueryControlHandle;

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

    fn send_raw(
        &self,
        mut result: Result<
            &fdomain_fuchsia_component_decl::ResolvedConfig,
            GetStructuredConfigError,
        >,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            RealmQueryGetStructuredConfigResponse,
            GetStructuredConfigError,
        >>(
            result.map(|config| (config,)),
            self.tx_id,
            0x16f88f6735bd204,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

impl fdomain_client::fidl::Responder for RealmQueryGetAllInstancesResponder {
    type ControlHandle = RealmQueryControlHandle;

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

    fn send_raw(
        &self,
        mut result: Result<
            fdomain_client::fidl::ClientEnd<InstanceIteratorMarker>,
            GetAllInstancesError,
        >,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            RealmQueryGetAllInstancesResponse,
            GetAllInstancesError,
        >>(
            result.map(|iterator| (iterator,)),
            self.tx_id,
            0x7b5a8775d30cad47,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

impl fdomain_client::fidl::Responder for RealmQueryConstructNamespaceResponder {
    type ControlHandle = RealmQueryControlHandle;

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

    fn send_raw(
        &self,
        mut result: Result<
            Vec<fdomain_fuchsia_component_runner::ComponentNamespaceEntry>,
            ConstructNamespaceError,
        >,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            RealmQueryConstructNamespaceResponse,
            ConstructNamespaceError,
        >>(
            result.as_mut().map_err(|e| *e).map(|namespace| (namespace.as_mut_slice(),)),
            self.tx_id,
            0x5ecb29c02c488eeb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

impl fdomain_client::fidl::Responder for RealmQueryOpenDirectoryResponder {
    type ControlHandle = RealmQueryControlHandle;

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

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

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

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

impl fdomain_client::fidl::Responder for RealmQueryConnectToStorageAdminResponder {
    type ControlHandle = RealmQueryControlHandle;

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

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

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

impl fdomain_client::fidl::ProtocolMarker for RouteValidatorMarker {
    type Proxy = RouteValidatorProxy;
    type RequestStream = RouteValidatorRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.sys2.RouteValidator";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for RouteValidatorMarker {}
pub type RouteValidatorValidateResult = Result<Vec<RouteReport>, fdomain_fuchsia_component::Error>;
pub type RouteValidatorRouteResult = Result<Vec<RouteReport>, RouteValidatorError>;

pub trait RouteValidatorProxyInterface: Send + Sync {
    type ValidateResponseFut: std::future::Future<Output = Result<RouteValidatorValidateResult, fidl::Error>>
        + Send;
    fn r#validate(&self, moniker: &str) -> Self::ValidateResponseFut;
    type RouteResponseFut: std::future::Future<Output = Result<RouteValidatorRouteResult, fidl::Error>>
        + Send;
    fn r#route(&self, moniker: &str, targets: &[RouteTarget]) -> Self::RouteResponseFut;
}

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

impl fdomain_client::fidl::Proxy for RouteValidatorProxy {
    type Protocol = RouteValidatorMarker;

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

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

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

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

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

    /// Routes all incoming and exposed capabilities of a component identified by the given
    /// moniker. If the routing failed, an error is returned in the response.
    /// This function may cause components to be resolved.
    ///
    /// Errors:
    /// * INVALID_ARGUMENTS: The given moniker is not valid.
    /// * INSTANCE_NOT_FOUND: No instance was found matching the given moniker.
    pub fn r#validate(
        &self,
        mut moniker: &str,
    ) -> fidl::client::QueryResponseFut<
        RouteValidatorValidateResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        RouteValidatorProxyInterface::r#validate(self, moniker)
    }

    /// Routes a component's used or exposed capabilities, and returns
    /// information about them.
    ///
    /// If `targets` is empty, returns results for all the component's used and
    /// exposed capabilities. Otherwise, returns only results for capabilities
    /// specified in `targets`.
    ///
    /// This method only supports routing namespace capabilities (protocols,
    /// directories, services, and storage).
    ///
    /// Errors:
    /// * INVALID_ARGUMENTS: The given moniker or name is not valid, or `name`
    ///   is not a namespace capability.
    /// * INSTANCE_NOT_FOUND: No instance was found matching the given moniker.
    /// * RESOURCE_NOT_FOUND: No capability was found matching one of the given names.
    pub fn r#route(
        &self,
        mut moniker: &str,
        mut targets: &[RouteTarget],
    ) -> fidl::client::QueryResponseFut<
        RouteValidatorRouteResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        RouteValidatorProxyInterface::r#route(self, moniker, targets)
    }
}

impl RouteValidatorProxyInterface for RouteValidatorProxy {
    type ValidateResponseFut = fidl::client::QueryResponseFut<
        RouteValidatorValidateResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#validate(&self, mut moniker: &str) -> Self::ValidateResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RouteValidatorValidateResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    RouteValidatorValidateResponse,
                    fdomain_fuchsia_component::Error,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                0x3360b96d5f86cdf4,
            >(_buf?)?;
            Ok(_response.map(|x| x.reports))
        }
        self.client
            .send_query_and_decode::<RouteValidatorValidateRequest, RouteValidatorValidateResult>(
                (moniker,),
                0x3360b96d5f86cdf4,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type RouteResponseFut = fidl::client::QueryResponseFut<
        RouteValidatorRouteResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#route(&self, mut moniker: &str, mut targets: &[RouteTarget]) -> Self::RouteResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RouteValidatorRouteResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<RouteValidatorRouteResponse, RouteValidatorError>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x51c9b268216d8239,
            >(_buf?)?;
            Ok(_response.map(|x| x.reports))
        }
        self.client.send_query_and_decode::<RouteValidatorRouteRequest, RouteValidatorRouteResult>(
            (moniker, targets),
            0x51c9b268216d8239,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for RouteValidatorRequestStream {
    type Protocol = RouteValidatorMarker;
    type ControlHandle = RouteValidatorControlHandle;

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

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

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

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

impl futures::Stream for RouteValidatorRequestStream {
    type Item = Result<RouteValidatorRequest, 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 RouteValidatorRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(e))) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

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

                std::task::Poll::Ready(Some(match header.ordinal {
                0x3360b96d5f86cdf4 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(RouteValidatorValidateRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<RouteValidatorValidateRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = RouteValidatorControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(RouteValidatorRequest::Validate {moniker: req.moniker,

                        responder: RouteValidatorValidateResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x51c9b268216d8239 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(RouteValidatorRouteRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<RouteValidatorRouteRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = RouteValidatorControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(RouteValidatorRequest::Route {moniker: req.moniker,
targets: req.targets,

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

#[derive(Debug)]
pub enum RouteValidatorRequest {
    /// Routes all incoming and exposed capabilities of a component identified by the given
    /// moniker. If the routing failed, an error is returned in the response.
    /// This function may cause components to be resolved.
    ///
    /// Errors:
    /// * INVALID_ARGUMENTS: The given moniker is not valid.
    /// * INSTANCE_NOT_FOUND: No instance was found matching the given moniker.
    Validate { moniker: String, responder: RouteValidatorValidateResponder },
    /// Routes a component's used or exposed capabilities, and returns
    /// information about them.
    ///
    /// If `targets` is empty, returns results for all the component's used and
    /// exposed capabilities. Otherwise, returns only results for capabilities
    /// specified in `targets`.
    ///
    /// This method only supports routing namespace capabilities (protocols,
    /// directories, services, and storage).
    ///
    /// Errors:
    /// * INVALID_ARGUMENTS: The given moniker or name is not valid, or `name`
    ///   is not a namespace capability.
    /// * INSTANCE_NOT_FOUND: No instance was found matching the given moniker.
    /// * RESOURCE_NOT_FOUND: No capability was found matching one of the given names.
    Route { moniker: String, targets: Vec<RouteTarget>, responder: RouteValidatorRouteResponder },
}

impl RouteValidatorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_validate(self) -> Option<(String, RouteValidatorValidateResponder)> {
        if let RouteValidatorRequest::Validate { moniker, responder } = self {
            Some((moniker, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_route(self) -> Option<(String, Vec<RouteTarget>, RouteValidatorRouteResponder)> {
        if let RouteValidatorRequest::Route { moniker, targets, responder } = self {
            Some((moniker, targets, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            RouteValidatorRequest::Validate { .. } => "validate",
            RouteValidatorRequest::Route { .. } => "route",
        }
    }
}

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

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

    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

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

impl RouteValidatorControlHandle {}

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

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

impl fdomain_client::fidl::Responder for RouteValidatorValidateResponder {
    type ControlHandle = RouteValidatorControlHandle;

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

    fn send_raw(
        &self,
        mut result: Result<&[RouteReport], fdomain_fuchsia_component::Error>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            RouteValidatorValidateResponse,
            fdomain_fuchsia_component::Error,
        >>(
            result.map(|reports| (reports,)),
            self.tx_id,
            0x3360b96d5f86cdf4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

impl fdomain_client::fidl::Responder for RouteValidatorRouteResponder {
    type ControlHandle = RouteValidatorControlHandle;

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

    fn send_raw(
        &self,
        mut result: Result<&[RouteReport], RouteValidatorError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            RouteValidatorRouteResponse,
            RouteValidatorError,
        >>(
            result.map(|reports| (reports,)),
            self.tx_id,
            0x51c9b268216d8239,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fdomain_client::fidl::ProtocolMarker for StorageAdminMarker {
    type Proxy = StorageAdminProxy;
    type RequestStream = StorageAdminRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.sys2.StorageAdmin";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for StorageAdminMarker {}
pub type StorageAdminOpenStorageResult = Result<(), fdomain_fuchsia_component::Error>;
pub type StorageAdminListStorageInRealmResult = Result<(), fdomain_fuchsia_component::Error>;
pub type StorageAdminOpenComponentStorageByIdResult = Result<(), fdomain_fuchsia_component::Error>;
pub type StorageAdminDeleteComponentStorageResult = Result<(), fdomain_fuchsia_component::Error>;
pub type StorageAdminGetStatusResult = Result<StorageStatus, StatusError>;
pub type StorageAdminDeleteAllStorageContentsResult = Result<(), DeletionError>;

pub trait StorageAdminProxyInterface: Send + Sync {
    type OpenStorageResponseFut: std::future::Future<Output = Result<StorageAdminOpenStorageResult, fidl::Error>>
        + Send;
    fn r#open_storage(
        &self,
        relative_moniker: &str,
        object: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::NodeMarker>,
    ) -> Self::OpenStorageResponseFut;
    type ListStorageInRealmResponseFut: std::future::Future<Output = Result<StorageAdminListStorageInRealmResult, fidl::Error>>
        + Send;
    fn r#list_storage_in_realm(
        &self,
        relative_moniker: &str,
        iterator: fdomain_client::fidl::ServerEnd<StorageIteratorMarker>,
    ) -> Self::ListStorageInRealmResponseFut;
    type OpenComponentStorageByIdResponseFut: std::future::Future<
            Output = Result<StorageAdminOpenComponentStorageByIdResult, fidl::Error>,
        > + Send;
    fn r#open_component_storage_by_id(
        &self,
        id: &str,
        object: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::NodeMarker>,
    ) -> Self::OpenComponentStorageByIdResponseFut;
    type DeleteComponentStorageResponseFut: std::future::Future<Output = Result<StorageAdminDeleteComponentStorageResult, fidl::Error>>
        + Send;
    fn r#delete_component_storage(
        &self,
        relative_moniker: &str,
    ) -> Self::DeleteComponentStorageResponseFut;
    type GetStatusResponseFut: std::future::Future<Output = Result<StorageAdminGetStatusResult, fidl::Error>>
        + Send;
    fn r#get_status(&self) -> Self::GetStatusResponseFut;
    type DeleteAllStorageContentsResponseFut: std::future::Future<
            Output = Result<StorageAdminDeleteAllStorageContentsResult, fidl::Error>,
        > + Send;
    fn r#delete_all_storage_contents(&self) -> Self::DeleteAllStorageContentsResponseFut;
}

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

impl fdomain_client::fidl::Proxy for StorageAdminProxy {
    type Protocol = StorageAdminMarker;

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

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

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

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

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

    /// Opens the isolated directory for the given component. The open request will provision
    /// the storage if it hasn't been already.
    pub fn r#open_storage(
        &self,
        mut relative_moniker: &str,
        mut object: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::NodeMarker>,
    ) -> fidl::client::QueryResponseFut<
        StorageAdminOpenStorageResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        StorageAdminProxyInterface::r#open_storage(self, relative_moniker, object)
    }

    /// Lists the descendant components under the specified realm that use the storage
    /// capability.
    /// Returns INSTANCE_NOT_FOUND if the realm does not exist, and INVALID_ARGS if
    /// |relative_moniker| is malformed.
    pub fn r#list_storage_in_realm(
        &self,
        mut relative_moniker: &str,
        mut iterator: fdomain_client::fidl::ServerEnd<StorageIteratorMarker>,
    ) -> fidl::client::QueryResponseFut<
        StorageAdminListStorageInRealmResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        StorageAdminProxyInterface::r#list_storage_in_realm(self, relative_moniker, iterator)
    }

    /// Opens the isolated directory for the given storage ID. The open request will provision
    /// the storage if it hasn't been already.
    pub fn r#open_component_storage_by_id(
        &self,
        mut id: &str,
        mut object: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::NodeMarker>,
    ) -> fidl::client::QueryResponseFut<
        StorageAdminOpenComponentStorageByIdResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        StorageAdminProxyInterface::r#open_component_storage_by_id(self, id, object)
    }

    /// Deletes the contents of the storage for this component. The moniker can be a regular
    /// moniker (ie, "foo/bar") or a moniker with internal instance IDs (unusual, ie, "foo:0/bar:0").
    /// Preserves the component's subdirectory itself within the storage backing directory.
    pub fn r#delete_component_storage(
        &self,
        mut relative_moniker: &str,
    ) -> fidl::client::QueryResponseFut<
        StorageAdminDeleteComponentStorageResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        StorageAdminProxyInterface::r#delete_component_storage(self, relative_moniker)
    }

    /// Get the current status of the storage.
    pub fn r#get_status(
        &self,
    ) -> fidl::client::QueryResponseFut<
        StorageAdminGetStatusResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        StorageAdminProxyInterface::r#get_status(self)
    }

    /// Deletes the contents of all the storage. Storage directories are retained so any components
    /// using storage will be able to continue using it to create new files and directories.
    /// Returns fuchsia.component.Error::INTERNAL only if no storage at all could be cleared.
    /// Returns successfully even if some errors happen during the deletion progress.
    pub fn r#delete_all_storage_contents(
        &self,
    ) -> fidl::client::QueryResponseFut<
        StorageAdminDeleteAllStorageContentsResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        StorageAdminProxyInterface::r#delete_all_storage_contents(self)
    }
}

impl StorageAdminProxyInterface for StorageAdminProxy {
    type OpenStorageResponseFut = fidl::client::QueryResponseFut<
        StorageAdminOpenStorageResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#open_storage(
        &self,
        mut relative_moniker: &str,
        mut object: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::NodeMarker>,
    ) -> Self::OpenStorageResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StorageAdminOpenStorageResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fdomain_fuchsia_component::Error,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                0x6ceaa5904cfe4377,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<StorageAdminOpenStorageRequest, StorageAdminOpenStorageResult>(
                (relative_moniker, object),
                0x6ceaa5904cfe4377,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type ListStorageInRealmResponseFut = fidl::client::QueryResponseFut<
        StorageAdminListStorageInRealmResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#list_storage_in_realm(
        &self,
        mut relative_moniker: &str,
        mut iterator: fdomain_client::fidl::ServerEnd<StorageIteratorMarker>,
    ) -> Self::ListStorageInRealmResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StorageAdminListStorageInRealmResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fdomain_fuchsia_component::Error,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                0x764f6d1f083e8bfb,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            StorageAdminListStorageInRealmRequest,
            StorageAdminListStorageInRealmResult,
        >(
            (relative_moniker, iterator,),
            0x764f6d1f083e8bfb,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type OpenComponentStorageByIdResponseFut = fidl::client::QueryResponseFut<
        StorageAdminOpenComponentStorageByIdResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#open_component_storage_by_id(
        &self,
        mut id: &str,
        mut object: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::NodeMarker>,
    ) -> Self::OpenComponentStorageByIdResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StorageAdminOpenComponentStorageByIdResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fdomain_fuchsia_component::Error,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                0x4802102cc55d5df1,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            StorageAdminOpenComponentStorageByIdRequest,
            StorageAdminOpenComponentStorageByIdResult,
        >(
            (id, object,),
            0x4802102cc55d5df1,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type DeleteComponentStorageResponseFut = fidl::client::QueryResponseFut<
        StorageAdminDeleteComponentStorageResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#delete_component_storage(
        &self,
        mut relative_moniker: &str,
    ) -> Self::DeleteComponentStorageResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StorageAdminDeleteComponentStorageResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fdomain_fuchsia_component::Error,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                0x1677c1cdfcdbf45a,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            StorageAdminDeleteComponentStorageRequest,
            StorageAdminDeleteComponentStorageResult,
        >(
            (relative_moniker,),
            0x1677c1cdfcdbf45a,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetStatusResponseFut = fidl::client::QueryResponseFut<
        StorageAdminGetStatusResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_status(&self) -> Self::GetStatusResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StorageAdminGetStatusResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<StorageStatus, StatusError>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x7729e325a6c526c8,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, StorageAdminGetStatusResult>(
                (),
                0x7729e325a6c526c8,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type DeleteAllStorageContentsResponseFut = fidl::client::QueryResponseFut<
        StorageAdminDeleteAllStorageContentsResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#delete_all_storage_contents(&self) -> Self::DeleteAllStorageContentsResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StorageAdminDeleteAllStorageContentsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, DeletionError>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x2ee980b4b2d24adb,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            StorageAdminDeleteAllStorageContentsResult,
        >(
            (),
            0x2ee980b4b2d24adb,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for StorageAdminRequestStream {
    type Protocol = StorageAdminMarker;
    type ControlHandle = StorageAdminControlHandle;

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

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

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

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

impl futures::Stream for StorageAdminRequestStream {
    type Item = Result<StorageAdminRequest, 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 StorageAdminRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(e))) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x6ceaa5904cfe4377 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            StorageAdminOpenStorageRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<StorageAdminOpenStorageRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StorageAdminControlHandle { inner: this.inner.clone() };
                        Ok(StorageAdminRequest::OpenStorage {
                            relative_moniker: req.relative_moniker,
                            object: req.object,

                            responder: StorageAdminOpenStorageResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x764f6d1f083e8bfb => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            StorageAdminListStorageInRealmRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<StorageAdminListStorageInRealmRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StorageAdminControlHandle { inner: this.inner.clone() };
                        Ok(StorageAdminRequest::ListStorageInRealm {
                            relative_moniker: req.relative_moniker,
                            iterator: req.iterator,

                            responder: StorageAdminListStorageInRealmResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4802102cc55d5df1 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            StorageAdminOpenComponentStorageByIdRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<StorageAdminOpenComponentStorageByIdRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StorageAdminControlHandle { inner: this.inner.clone() };
                        Ok(StorageAdminRequest::OpenComponentStorageById {
                            id: req.id,
                            object: req.object,

                            responder: StorageAdminOpenComponentStorageByIdResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1677c1cdfcdbf45a => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            StorageAdminDeleteComponentStorageRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<StorageAdminDeleteComponentStorageRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StorageAdminControlHandle { inner: this.inner.clone() };
                        Ok(StorageAdminRequest::DeleteComponentStorage {
                            relative_moniker: req.relative_moniker,

                            responder: StorageAdminDeleteComponentStorageResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7729e325a6c526c8 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StorageAdminControlHandle { inner: this.inner.clone() };
                        Ok(StorageAdminRequest::GetStatus {
                            responder: StorageAdminGetStatusResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2ee980b4b2d24adb => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StorageAdminControlHandle { inner: this.inner.clone() };
                        Ok(StorageAdminRequest::DeleteAllStorageContents {
                            responder: StorageAdminDeleteAllStorageContentsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <StorageAdminMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

#[derive(Debug)]
pub enum StorageAdminRequest {
    /// Opens the isolated directory for the given component. The open request will provision
    /// the storage if it hasn't been already.
    OpenStorage {
        relative_moniker: String,
        object: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::NodeMarker>,
        responder: StorageAdminOpenStorageResponder,
    },
    /// Lists the descendant components under the specified realm that use the storage
    /// capability.
    /// Returns INSTANCE_NOT_FOUND if the realm does not exist, and INVALID_ARGS if
    /// |relative_moniker| is malformed.
    ListStorageInRealm {
        relative_moniker: String,
        iterator: fdomain_client::fidl::ServerEnd<StorageIteratorMarker>,
        responder: StorageAdminListStorageInRealmResponder,
    },
    /// Opens the isolated directory for the given storage ID. The open request will provision
    /// the storage if it hasn't been already.
    OpenComponentStorageById {
        id: String,
        object: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::NodeMarker>,
        responder: StorageAdminOpenComponentStorageByIdResponder,
    },
    /// Deletes the contents of the storage for this component. The moniker can be a regular
    /// moniker (ie, "foo/bar") or a moniker with internal instance IDs (unusual, ie, "foo:0/bar:0").
    /// Preserves the component's subdirectory itself within the storage backing directory.
    DeleteComponentStorage {
        relative_moniker: String,
        responder: StorageAdminDeleteComponentStorageResponder,
    },
    /// Get the current status of the storage.
    GetStatus { responder: StorageAdminGetStatusResponder },
    /// Deletes the contents of all the storage. Storage directories are retained so any components
    /// using storage will be able to continue using it to create new files and directories.
    /// Returns fuchsia.component.Error::INTERNAL only if no storage at all could be cleared.
    /// Returns successfully even if some errors happen during the deletion progress.
    DeleteAllStorageContents { responder: StorageAdminDeleteAllStorageContentsResponder },
}

impl StorageAdminRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_open_storage(
        self,
    ) -> Option<(
        String,
        fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::NodeMarker>,
        StorageAdminOpenStorageResponder,
    )> {
        if let StorageAdminRequest::OpenStorage { relative_moniker, object, responder } = self {
            Some((relative_moniker, object, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_list_storage_in_realm(
        self,
    ) -> Option<(
        String,
        fdomain_client::fidl::ServerEnd<StorageIteratorMarker>,
        StorageAdminListStorageInRealmResponder,
    )> {
        if let StorageAdminRequest::ListStorageInRealm { relative_moniker, iterator, responder } =
            self
        {
            Some((relative_moniker, iterator, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_open_component_storage_by_id(
        self,
    ) -> Option<(
        String,
        fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::NodeMarker>,
        StorageAdminOpenComponentStorageByIdResponder,
    )> {
        if let StorageAdminRequest::OpenComponentStorageById { id, object, responder } = self {
            Some((id, object, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_delete_component_storage(
        self,
    ) -> Option<(String, StorageAdminDeleteComponentStorageResponder)> {
        if let StorageAdminRequest::DeleteComponentStorage { relative_moniker, responder } = self {
            Some((relative_moniker, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_status(self) -> Option<(StorageAdminGetStatusResponder)> {
        if let StorageAdminRequest::GetStatus { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_delete_all_storage_contents(
        self,
    ) -> Option<(StorageAdminDeleteAllStorageContentsResponder)> {
        if let StorageAdminRequest::DeleteAllStorageContents { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            StorageAdminRequest::OpenStorage { .. } => "open_storage",
            StorageAdminRequest::ListStorageInRealm { .. } => "list_storage_in_realm",
            StorageAdminRequest::OpenComponentStorageById { .. } => "open_component_storage_by_id",
            StorageAdminRequest::DeleteComponentStorage { .. } => "delete_component_storage",
            StorageAdminRequest::GetStatus { .. } => "get_status",
            StorageAdminRequest::DeleteAllStorageContents { .. } => "delete_all_storage_contents",
        }
    }
}

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

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

    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

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

impl StorageAdminControlHandle {}

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

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

impl fdomain_client::fidl::Responder for StorageAdminOpenStorageResponder {
    type ControlHandle = StorageAdminControlHandle;

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

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

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

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

impl fdomain_client::fidl::Responder for StorageAdminListStorageInRealmResponder {
    type ControlHandle = StorageAdminControlHandle;

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

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

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

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

impl fdomain_client::fidl::Responder for StorageAdminOpenComponentStorageByIdResponder {
    type ControlHandle = StorageAdminControlHandle;

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

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

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

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

impl fdomain_client::fidl::Responder for StorageAdminDeleteComponentStorageResponder {
    type ControlHandle = StorageAdminControlHandle;

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

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

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

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

impl fdomain_client::fidl::Responder for StorageAdminGetStatusResponder {
    type ControlHandle = StorageAdminControlHandle;

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

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

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

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

impl fdomain_client::fidl::Responder for StorageAdminDeleteAllStorageContentsResponder {
    type ControlHandle = StorageAdminControlHandle;

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

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

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

impl fdomain_client::fidl::ProtocolMarker for StorageIteratorMarker {
    type Proxy = StorageIteratorProxy;
    type RequestStream = StorageIteratorRequestStream;

    const DEBUG_NAME: &'static str = "(anonymous) StorageIterator";
}

pub trait StorageIteratorProxyInterface: Send + Sync {
    type NextResponseFut: std::future::Future<Output = Result<Vec<String>, fidl::Error>> + Send;
    fn r#next(&self) -> Self::NextResponseFut;
}

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

impl fdomain_client::fidl::Proxy for StorageIteratorProxy {
    type Protocol = StorageIteratorMarker;

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

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

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

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

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

    /// Retrieve the next set of components using the storage capability. The returned monikers
    /// are relative to the component that declares the storage capability. Returns an empty
    /// vector after all components have been returned.
    pub fn r#next(
        &self,
    ) -> fidl::client::QueryResponseFut<Vec<String>, fdomain_client::fidl::FDomainResourceDialect>
    {
        StorageIteratorProxyInterface::r#next(self)
    }
}

impl StorageIteratorProxyInterface for StorageIteratorProxy {
    type NextResponseFut =
        fidl::client::QueryResponseFut<Vec<String>, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#next(&self) -> Self::NextResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<String>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                StorageIteratorNextResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x7a6b21f15fd01b72,
            >(_buf?)?;
            Ok(_response.relative_monikers)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<String>>(
            (),
            0x7a6b21f15fd01b72,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for StorageIteratorRequestStream {
    type Protocol = StorageIteratorMarker;
    type ControlHandle = StorageIteratorControlHandle;

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

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

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

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

impl futures::Stream for StorageIteratorRequestStream {
    type Item = Result<StorageIteratorRequest, 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 StorageIteratorRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(e))) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

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

                std::task::Poll::Ready(Some(match header.ordinal {
                0x7a6b21f15fd01b72 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = StorageIteratorControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(StorageIteratorRequest::Next {
                        responder: StorageIteratorNextResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <StorageIteratorMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// An iterator protocol for returning a set of components using a storage capability. See
/// |StorageAdmin.ListStorageInRealm| for more information.
#[derive(Debug)]
pub enum StorageIteratorRequest {
    /// Retrieve the next set of components using the storage capability. The returned monikers
    /// are relative to the component that declares the storage capability. Returns an empty
    /// vector after all components have been returned.
    Next { responder: StorageIteratorNextResponder },
}

impl StorageIteratorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_next(self) -> Option<(StorageIteratorNextResponder)> {
        if let StorageIteratorRequest::Next { responder } = self { Some((responder)) } else { None }
    }

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

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

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

    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

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

impl StorageIteratorControlHandle {}

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

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

impl fdomain_client::fidl::Responder for StorageIteratorNextResponder {
    type ControlHandle = StorageIteratorControlHandle;

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

    fn send_raw(&self, mut relative_monikers: &[String]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<StorageIteratorNextResponse>(
            (relative_monikers,),
            self.tx_id,
            0x7a6b21f15fd01b72,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fdomain_client::fidl::ProtocolMarker for SystemControllerMarker {
    type Proxy = SystemControllerProxy;
    type RequestStream = SystemControllerRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.sys2.SystemController";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for SystemControllerMarker {}

pub trait SystemControllerProxyInterface: Send + Sync {
    type ShutdownResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#shutdown(&self) -> Self::ShutdownResponseFut;
}

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

impl fdomain_client::fidl::Proxy for SystemControllerProxy {
    type Protocol = SystemControllerMarker;

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

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

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

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

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

    /// Stop all components, return an empty result, close this protocol's
    /// channel, and exit ComponentManager. If this is the root ComponentManager
    /// is exited we expect the system will reboot.
    pub fn r#shutdown(
        &self,
    ) -> fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect> {
        SystemControllerProxyInterface::r#shutdown(self)
    }
}

impl SystemControllerProxyInterface for SystemControllerProxy {
    type ShutdownResponseFut =
        fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect>;
    fn r#shutdown(&self) -> Self::ShutdownResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fdomain_client::fidl::FDomainResourceDialect,
                0x25f56c938344e549,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
            (),
            0x25f56c938344e549,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for SystemControllerRequestStream {
    type Protocol = SystemControllerMarker;
    type ControlHandle = SystemControllerControlHandle;

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

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

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

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

impl futures::Stream for SystemControllerRequestStream {
    type Item = Result<SystemControllerRequest, 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 SystemControllerRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(e))) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

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

                std::task::Poll::Ready(Some(match header.ordinal {
                0x25f56c938344e549 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SystemControllerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SystemControllerRequest::Shutdown {
                        responder: SystemControllerShutdownResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <SystemControllerMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// An interface implemented by ComponentManager that requests the
/// ComponentManager stop all components and exit.
#[derive(Debug)]
pub enum SystemControllerRequest {
    /// Stop all components, return an empty result, close this protocol's
    /// channel, and exit ComponentManager. If this is the root ComponentManager
    /// is exited we expect the system will reboot.
    Shutdown { responder: SystemControllerShutdownResponder },
}

impl SystemControllerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_shutdown(self) -> Option<(SystemControllerShutdownResponder)> {
        if let SystemControllerRequest::Shutdown { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

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

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

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

    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

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

impl SystemControllerControlHandle {}

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

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

impl fdomain_client::fidl::Responder for SystemControllerShutdownResponder {
    type ControlHandle = SystemControllerControlHandle;

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

    fn send_raw(&self) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
            (),
            self.tx_id,
            0x25f56c938344e549,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

mod internal {
    use super::*;

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

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

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

        #[inline(always)]
        fn decode_is_copy() -> bool {
            true
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            CrashIntrospectFindComponentByThreadKoidRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut CrashIntrospectFindComponentByThreadKoidRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CrashIntrospectFindComponentByThreadKoidRequest>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut CrashIntrospectFindComponentByThreadKoidRequest).write_unaligned(
                    (self as *const CrashIntrospectFindComponentByThreadKoidRequest).read(),
                );
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
            }
            Ok(())
        }
    }
    unsafe impl<T0: fidl::encoding::Encode<u64, fdomain_client::fidl::FDomainResourceDialect>>
        fidl::encoding::Encode<
            CrashIntrospectFindComponentByThreadKoidRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CrashIntrospectFindComponentByThreadKoidRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

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

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
            }
            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            LifecycleControllerCreateInstanceRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut LifecycleControllerCreateInstanceRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<LifecycleControllerCreateInstanceRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<LifecycleControllerCreateInstanceRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(&self.parent_moniker),
                    <fdomain_fuchsia_component_decl::CollectionRef as fidl::encoding::ValueTypeMarker>::borrow(&self.collection),
                    <fdomain_fuchsia_component_decl::Child as fidl::encoding::ValueTypeMarker>::borrow(&self.decl),
                    <fdomain_fuchsia_component::CreateChildArgs as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.args),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::BoundedString<4096>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fdomain_fuchsia_component_decl::CollectionRef,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T2: fidl::encoding::Encode<
                fdomain_fuchsia_component_decl::Child,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T3: fidl::encoding::Encode<
                fdomain_fuchsia_component::CreateChildArgs,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            LifecycleControllerCreateInstanceRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1, T2, T3)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<LifecycleControllerCreateInstanceRequest>(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)?;
            self.3.encode(encoder, offset + 48, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for LifecycleControllerCreateInstanceRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                parent_moniker: fidl::new_empty!(
                    fidl::encoding::BoundedString<4096>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                collection: fidl::new_empty!(
                    fdomain_fuchsia_component_decl::CollectionRef,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                decl: fidl::new_empty!(
                    fdomain_fuchsia_component_decl::Child,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                args: fidl::new_empty!(
                    fdomain_fuchsia_component::CreateChildArgs,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::BoundedString<4096>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.parent_moniker,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fdomain_fuchsia_component_decl::CollectionRef,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.collection,
                decoder,
                offset + 16,
                _depth
            )?;
            fidl::decode!(
                fdomain_fuchsia_component_decl::Child,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.decl,
                decoder,
                offset + 32,
                _depth
            )?;
            fidl::decode!(
                fdomain_fuchsia_component::CreateChildArgs,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.args,
                decoder,
                offset + 48,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for LifecycleControllerStartInstanceRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                moniker: fidl::new_empty!(
                    fidl::encoding::BoundedString<4096>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                binder: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fdomain_client::fidl::ServerEnd<fdomain_fuchsia_component::BinderMarker>,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for LifecycleControllerStartInstanceWithArgsRequest {
        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 LifecycleControllerStartInstanceWithArgsRequest {
        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<
            LifecycleControllerStartInstanceWithArgsRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut LifecycleControllerStartInstanceWithArgsRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<LifecycleControllerStartInstanceWithArgsRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<LifecycleControllerStartInstanceWithArgsRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(&self.moniker),
                    <fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<fdomain_fuchsia_component::BinderMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.binder),
                    <fdomain_fuchsia_component::StartChildArgs as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.args),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::BoundedString<4096>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<
                    fdomain_client::fidl::ServerEnd<fdomain_fuchsia_component::BinderMarker>,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T2: fidl::encoding::Encode<
                fdomain_fuchsia_component::StartChildArgs,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            LifecycleControllerStartInstanceWithArgsRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<LifecycleControllerStartInstanceWithArgsRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            self.2.encode(encoder, offset + 24, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for LifecycleControllerStartInstanceWithArgsRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                moniker: fidl::new_empty!(
                    fidl::encoding::BoundedString<4096>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                binder: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fdomain_client::fidl::ServerEnd<fdomain_fuchsia_component::BinderMarker>,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                args: fidl::new_empty!(
                    fdomain_fuchsia_component::StartChildArgs,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for RealmQueryConnectToStorageAdminRequest {
        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 RealmQueryConnectToStorageAdminRequest {
        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<
            RealmQueryConnectToStorageAdminRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut RealmQueryConnectToStorageAdminRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RealmQueryConnectToStorageAdminRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RealmQueryConnectToStorageAdminRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(&self.moniker),
                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(&self.storage_name),
                    <fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<StorageAdminMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.server_end),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::BoundedString<4096>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::BoundedString<100>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T2: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<StorageAdminMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            RealmQueryConnectToStorageAdminRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RealmQueryConnectToStorageAdminRequest>(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, fdomain_client::fidl::FDomainResourceDialect>
        for RealmQueryConnectToStorageAdminRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                moniker: fidl::new_empty!(
                    fidl::encoding::BoundedString<4096>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                storage_name: fidl::new_empty!(
                    fidl::encoding::BoundedString<100>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                server_end: fidl::new_empty!(
                    fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<StorageAdminMarker>>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(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<4096>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.moniker,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::BoundedString<100>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.storage_name,
                decoder,
                offset + 16,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<StorageAdminMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.server_end,
                decoder,
                offset + 32,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            RealmQueryOpenDirectoryRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut RealmQueryOpenDirectoryRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RealmQueryOpenDirectoryRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RealmQueryOpenDirectoryRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(&self.moniker),
                    <OpenDirType as fidl::encoding::ValueTypeMarker>::borrow(&self.dir_type),
                    <fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::DirectoryMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.object),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::BoundedString<4096>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<OpenDirType, fdomain_client::fidl::FDomainResourceDialect>,
        T2: fidl::encoding::Encode<
                fidl::encoding::Endpoint<
                    fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::DirectoryMarker>,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            RealmQueryOpenDirectoryRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RealmQueryOpenDirectoryRequest>(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 + 20, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for RealmQueryOpenDirectoryRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                moniker: fidl::new_empty!(
                    fidl::encoding::BoundedString<4096>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                dir_type: fidl::new_empty!(
                    OpenDirType,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                object: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::DirectoryMarker>,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::BoundedString<4096>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.moniker,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                OpenDirType,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.dir_type,
                decoder,
                offset + 16,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<
                    fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::DirectoryMarker>,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.object,
                decoder,
                offset + 20,
                _depth
            )?;
            Ok(())
        }
    }

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

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for RealmQueryConstructNamespaceResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                namespace: fidl::new_empty!(
                    fidl::encoding::UnboundedVector<
                        fdomain_fuchsia_component_runner::ComponentNamespaceEntry,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

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

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

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for RealmQueryGetAllInstancesResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                iterator: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fdomain_client::fidl::ClientEnd<InstanceIteratorMarker>,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

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

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

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for RealmQueryGetResolvedDeclarationResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                iterator: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fdomain_client::fidl::ClientEnd<ManifestBytesIteratorMarker>,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

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

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

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for RealmQueryResolveDeclarationResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                iterator: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fdomain_client::fidl::ClientEnd<ManifestBytesIteratorMarker>,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

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

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

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

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

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

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for StorageAdminListStorageInRealmRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                relative_moniker: fidl::new_empty!(
                    fidl::encoding::BoundedString<4096>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                iterator: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fdomain_client::fidl::ServerEnd<StorageIteratorMarker>,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

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

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

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

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

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

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for StorageAdminOpenComponentStorageByIdRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                id: fidl::new_empty!(
                    fidl::encoding::BoundedString<64>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                object: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::NodeMarker>,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

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

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

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

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

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

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for StorageAdminOpenStorageRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                relative_moniker: fidl::new_empty!(
                    fidl::encoding::BoundedString<4096>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                object: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::NodeMarker>,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

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