fdomain_fuchsia_component/

fdomain_fuchsia_component.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_component__common::*;
use futures::future::{self, MaybeDone, TryFutureExt};
use zx_status;

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ControllerOpenExposedDirRequest {
    pub exposed_dir: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::DirectoryMarker>,
}

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

#[derive(Debug, PartialEq)]
pub struct ControllerStartRequest {
    pub args: StartChildArgs,
    pub execution_controller: fdomain_client::fidl::ServerEnd<ExecutionControllerMarker>,
}

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

#[derive(Debug, PartialEq)]
pub struct ControllerGetExposedDictionaryResponse {
    pub dictionary: fdomain_fuchsia_component_sandbox::DictionaryRef,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ControllerGetOutputDictionaryResponse {
    pub dictionary: fdomain_client::EventPair,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ControllerIsStartedResponse {
    pub is_started: bool,
}

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

#[derive(Debug, PartialEq)]
pub struct EventStreamGetNextResponse {
    pub events: Vec<Event>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct IntrospectorGetMonikerRequest {
    pub component_instance: fdomain_client::Event,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct NamespaceCreate2Request {
    pub entries: Vec<NamespaceInputEntry2>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct NamespaceCreateRequest {
    pub entries: Vec<NamespaceInputEntry>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct NamespaceInputEntry {
    pub path: String,
    pub dictionary:
        fdomain_client::fidl::ClientEnd<fdomain_fuchsia_component_sandbox::DictionaryMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct NamespaceInputEntry2 {
    /// The path at which the entry will exist in the namespace.
    pub path: String,
    /// A capability (created using fuchsia.component.runtime.Capabilities) to
    /// install in the namespace. Currently only dictionaries are supported.
    pub capability: fdomain_client::EventPair,
}

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

#[derive(Debug, PartialEq)]
pub struct NamespaceCreate2Response {
    pub entries: Vec<NamespaceEntry>,
}

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

#[derive(Debug, PartialEq)]
pub struct NamespaceCreateResponse {
    pub entries: Vec<NamespaceEntry>,
}

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

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

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

#[derive(Debug, PartialEq)]
pub struct RealmGetChildOutputDictionaryDeprecatedRequest {
    pub child: fdomain_fuchsia_component_decl::ChildRef,
}

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

#[derive(Debug, PartialEq)]
pub struct RealmGetChildOutputDictionaryRequest {
    pub child: fdomain_fuchsia_component_decl::ChildRef,
}

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

#[derive(Debug, PartialEq)]
pub struct RealmListChildrenRequest {
    pub collection: fdomain_fuchsia_component_decl::CollectionRef,
    pub iter: fdomain_client::fidl::ServerEnd<ChildIteratorMarker>,
}

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

#[derive(Debug, PartialEq)]
pub struct RealmOpenControllerRequest {
    pub child: fdomain_fuchsia_component_decl::ChildRef,
    pub controller: fdomain_client::fidl::ServerEnd<ControllerMarker>,
}

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

#[derive(Debug, PartialEq)]
pub struct RealmOpenExposedDirRequest {
    pub child: fdomain_fuchsia_component_decl::ChildRef,
    pub exposed_dir: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::DirectoryMarker>,
}

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

#[derive(Debug, PartialEq)]
pub struct RealmGetChildOutputDictionaryDeprecatedResponse {
    pub dictionary: fdomain_fuchsia_component_sandbox::DictionaryRef,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RealmGetChildOutputDictionaryResponse {
    pub dictionary: fdomain_client::EventPair,
}

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

#[derive(Debug, PartialEq)]
pub struct RealmGetResolvedInfoResponse {
    pub resolved_info: fdomain_fuchsia_component_resolution::Component,
}

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

#[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
{
}

/// Payload for CapabilityRequested events
#[derive(Debug, Default, PartialEq)]
pub struct CapabilityRequestedPayload {
    /// The name of the capability.
    pub name: Option<String>,
    /// A handle to the server end of the channel to host
    /// capability.
    pub capability: Option<fdomain_client::Channel>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct CreateChildArgs {
    /// The numbered handles to pass to the component instance.
    ///
    /// If the runner for the component does not support the numbered handles it is
    /// expected to close the handles.
    pub numbered_handles: Option<Vec<fdomain_fuchsia_process::HandleInfo>>,
    /// Dynamic offers that will target the component instance.
    ///
    /// Including `OfferDecl`s in this vector will cause additional capabilities
    /// to be offered to the newly created child, beyond the `OfferDecl`s in the
    /// parent's `ComponentDecl` that target the collection.
    ///
    /// Any kind of offer (e.g., protocol, directory) can be used as a dynamic
    /// offer. Any source that would be valid for a static offer is also valid
    /// for a dynamic offer. Additionally, unlike static offers, dynamic offers
    /// can use a "sibling" dynamic child component as a source by setting the
    /// source to a `ChildRef` that sets the `collection` field.
    ///
    /// Dynamic offers always target the newly created child component. As a
    /// result, `OfferDecl`s in `dynamic_offers` must not set the `target`
    /// field, as its value is implied.
    ///
    /// If either the source (that is, the component named in the `source` field
    /// of the `OfferDecl`) or the target of a dynamic offer is destroyed, the
    /// offer itself is destroyed simultaneously.
    ///
    /// In order to set this field to a non-empty value, the collection in which
    /// the child component is being created must specify
    /// `ComponentDecl.allowed_offers = STATIC_AND_DYNAMIC`.
    pub dynamic_offers: Option<Vec<fdomain_fuchsia_component_decl::Offer>>,
    /// The controller for this component, which may be used to influence the
    /// component's lifecycle.
    pub controller: Option<fdomain_client::fidl::ServerEnd<ControllerMarker>>,
    /// A dictionary that contains extra capabilities for the component instance.
    /// This field should be considered deprecated in favor of
    /// `additional_inputs`. If both are set, an `INVALID_ARGUMENTS` error will
    /// be returned.
    pub dictionary: Option<fdomain_fuchsia_component_sandbox::DictionaryRef>,
    /// A handle to a dictionary created using
    /// fuchsia.component.runtime.Capabilities that contains additional
    /// capabilities that should be added to the inputs of the created child.
    pub additional_inputs: Option<fdomain_client::EventPair>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

/// Payload for DebugStarted events.
#[derive(Debug, Default, PartialEq)]
pub struct DebugStartedPayload {
    /// The directory served by the runner to present runtime and runner-specific information
    /// about the component. The other side is sent to the runner in ComponentStartInfo.
    /// For example, it can be queried to know whether the component is an ELF component and
    /// supports the break_on_start protocol below.
    pub runtime_dir: Option<fdomain_client::fidl::ClientEnd<fdomain_fuchsia_io::DirectoryMarker>>,
    /// An eventpair that can be used by debuggers to defer the launch of the component,
    /// e.g., ELF debuggers can setup the exception channel on the job while holding
    /// the eventpair, then drop the eventpair to notify the runner that processes could
    /// be created. The other side is sent to the runner in ComponentStartInfo.
    pub break_on_start: Option<fdomain_client::EventPair>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

/// Contains all information about a single event
#[derive(Debug, Default, PartialEq)]
pub struct Event {
    /// Information about the component for which this event was generated.
    pub header: Option<EventHeader>,
    /// Optional payload for some event types
    pub payload: Option<EventPayload>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

/// A single component namespace entry, which describes a namespace mount point
/// (`path`) and the directory backing it (`directory`). This type is usually
/// composed inside a vector.  See `ComponentStartInfo.ns` for more details.
#[derive(Debug, Default, PartialEq)]
pub struct NamespaceEntry {
    /// The mount point for the directory, including a
    /// leading slash. For example: "/pkg", "/svc", or "/config/data".
    pub path: Option<String>,
    /// The directory mounted at the above `path`.
    pub directory: Option<fdomain_client::fidl::ClientEnd<fdomain_fuchsia_io::DirectoryMarker>>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct StartChildArgs {
    /// The numbered handles to pass to the component instance.
    ///
    /// If the runner for the component does not support the numbered handles it
    /// is expected to close the handles.
    ///
    /// If set, the values given here will override the handles given in
    /// CreateChildArgs.
    pub numbered_handles: Option<Vec<fdomain_fuchsia_process::HandleInfo>>,
    /// The namespace generated by component manager will be extended to include
    /// any namespace entries listed here before being given to the component's
    /// runner.
    ///
    /// If there are any conflicting entries, an error will occur when starting
    /// the component.
    pub namespace_entries: Option<Vec<NamespaceEntry>>,
    /// A dictionary that contains extra capabilities for the component instance.
    /// This field should be considered deprecated in favor of
    /// `additional_inputs`. If both are set, an `INVALID_ARGUMENTS` error will
    /// be returned.
    pub dictionary: Option<fdomain_fuchsia_component_sandbox::DictionaryRef>,
    /// A handle to a dictionary created using
    /// fuchsia.component.runtime.Capabilities that contains additional
    /// capabilities that should be added to the inputs of the started program.
    pub additional_inputs: Option<fdomain_client::EventPair>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

/// Encapsulates additional data/protocols for some event types.
#[derive(Debug)]
pub enum EventPayload {
    /// Payload for CapabilityRequested events
    CapabilityRequested(CapabilityRequestedPayload),
    /// Payload for Purged events.
    Purged(PurgedPayload),
    /// Payload for Discovered events.
    Discovered(DiscoveredPayload),
    /// Payload for Destroyed events.
    Destroyed(DestroyedPayload),
    /// Payload for Resolved events
    Resolved(ResolvedPayload),
    /// Payload for Started events
    Started(StartedPayload),
    /// Payload for Stopped events
    Stopped(StoppedPayload),
    /// Payload for DebugStarted events
    DebugStarted(DebugStartedPayload),
    /// Payload for Unresolved events
    Unresolved(UnresolvedPayload),
    #[doc(hidden)]
    __SourceBreaking { unknown_ordinal: u64 },
}

/// Pattern that matches an unknown `EventPayload` member.
#[macro_export]
macro_rules! EventPayloadUnknown {
    () => {
        _
    };
}

// Custom PartialEq so that unknown variants are not equal to themselves.
impl PartialEq for EventPayload {
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (Self::CapabilityRequested(x), Self::CapabilityRequested(y)) => *x == *y,
            (Self::Purged(x), Self::Purged(y)) => *x == *y,
            (Self::Discovered(x), Self::Discovered(y)) => *x == *y,
            (Self::Destroyed(x), Self::Destroyed(y)) => *x == *y,
            (Self::Resolved(x), Self::Resolved(y)) => *x == *y,
            (Self::Started(x), Self::Started(y)) => *x == *y,
            (Self::Stopped(x), Self::Stopped(y)) => *x == *y,
            (Self::DebugStarted(x), Self::DebugStarted(y)) => *x == *y,
            (Self::Unresolved(x), Self::Unresolved(y)) => *x == *y,
            _ => false,
        }
    }
}

impl EventPayload {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::CapabilityRequested(_) => 1,
            Self::Purged(_) => 2,
            Self::Discovered(_) => 4,
            Self::Destroyed(_) => 5,
            Self::Resolved(_) => 6,
            Self::Started(_) => 7,
            Self::Stopped(_) => 8,
            Self::DebugStarted(_) => 9,
            Self::Unresolved(_) => 10,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

    #[inline]
    pub fn unknown_variant_for_testing() -> Self {
        Self::__SourceBreaking { unknown_ordinal: 0 }
    }

    #[inline]
    pub fn is_unknown(&self) -> bool {
        match self {
            Self::__SourceBreaking { .. } => true,
            _ => false,
        }
    }
}

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

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

impl fdomain_client::fidl::ProtocolMarker for BinderMarker {
    type Proxy = BinderProxy;
    type RequestStream = BinderRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.component.Binder";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for BinderMarker {}

pub trait BinderProxyInterface: Send + Sync {}

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

impl fdomain_client::fidl::Proxy for BinderProxy {
    type Protocol = BinderMarker;

    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 BinderProxy {
    /// Create a new Proxy for fuchsia.component/Binder.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name = <BinderMarker 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) -> BinderEventStream {
        BinderEventStream { event_receiver: self.client.take_event_receiver() }
    }
}

impl BinderProxyInterface for BinderProxy {}

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for BinderRequestStream {
    type Protocol = BinderMarker;
    type ControlHandle = BinderControlHandle;

    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 {
        BinderControlHandle { 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 BinderRequestStream {
    type Item = Result<BinderRequest, 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 BinderRequestStream 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:
                            <BinderMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// A framework-provided protocol that allows components that use it to bind to
/// the component that exposes it. The act of connecting to this protocol will
/// trigger the bind. Thus, this protocol contains no methods. For more details
/// on binding, see
/// https://fuchsia.dev/fuchsia-src/concepts/components/v2/lifecycle#binding.
///
/// When a component connects to protocol, the component exposing this capability
/// will be started if it's not already running. Upon a failure to start, the
/// component framework will close the server end of the channel with a
/// zx.Status epitaph.
#[derive(Debug)]
pub enum BinderRequest {}

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

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

impl fdomain_client::fidl::ControlHandle for BinderControlHandle {
    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 BinderControlHandle {}

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

impl fdomain_client::fidl::ProtocolMarker for ChildIteratorMarker {
    type Proxy = ChildIteratorProxy;
    type RequestStream = ChildIteratorRequestStream;

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

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

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

impl fdomain_client::fidl::Proxy for ChildIteratorProxy {
    type Protocol = ChildIteratorMarker;

    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 ChildIteratorProxy {
    /// Create a new Proxy for fuchsia.component/ChildIterator.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name =
            <ChildIteratorMarker 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) -> ChildIteratorEventStream {
        ChildIteratorEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Advance the iterator and return the next batch of children.
    ///
    /// Returns a vector of `ChildRef`. Returns an empty vector when there are
    /// no more children.
    pub fn r#next(
        &self,
    ) -> fidl::client::QueryResponseFut<
        Vec<fdomain_fuchsia_component_decl::ChildRef>,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        ChildIteratorProxyInterface::r#next(self)
    }
}

impl ChildIteratorProxyInterface for ChildIteratorProxy {
    type NextResponseFut = fidl::client::QueryResponseFut<
        Vec<fdomain_fuchsia_component_decl::ChildRef>,
        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<fdomain_fuchsia_component_decl::ChildRef>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ChildIteratorNextResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x40e4c3882b050d08,
            >(_buf?)?;
            Ok(_response.children)
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            Vec<fdomain_fuchsia_component_decl::ChildRef>,
        >(
            (),
            0x40e4c3882b050d08,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for ChildIteratorRequestStream {
    type Protocol = ChildIteratorMarker;
    type ControlHandle = ChildIteratorControlHandle;

    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 {
        ChildIteratorControlHandle { 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 ChildIteratorRequestStream {
    type Item = Result<ChildIteratorRequest, 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 ChildIteratorRequestStream 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 {
                0x40e4c3882b050d08 => {
                    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 = ChildIteratorControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(ChildIteratorRequest::Next {
                        responder: ChildIteratorNextResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <ChildIteratorMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// A protocol to iterate over the list of children in a realm.
#[derive(Debug)]
pub enum ChildIteratorRequest {
    /// Advance the iterator and return the next batch of children.
    ///
    /// Returns a vector of `ChildRef`. Returns an empty vector when there are
    /// no more children.
    Next { responder: ChildIteratorNextResponder },
}

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

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

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

impl fdomain_client::fidl::ControlHandle for ChildIteratorControlHandle {
    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 ChildIteratorControlHandle {}

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

/// Set the the channel to be shutdown (see [`ChildIteratorControlHandle::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 ChildIteratorNextResponder {
    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 ChildIteratorNextResponder {
    type ControlHandle = ChildIteratorControlHandle;

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

    fn send_raw(
        &self,
        mut children: &[fdomain_fuchsia_component_decl::ChildRef],
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<ChildIteratorNextResponse>(
            (children,),
            self.tx_id,
            0x40e4c3882b050d08,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fdomain_client::fidl::ProtocolMarker for ControllerMarker {
    type Proxy = ControllerProxy;
    type RequestStream = ControllerRequestStream;

    const DEBUG_NAME: &'static str = "(anonymous) Controller";
}
pub type ControllerStartResult = Result<(), Error>;
pub type ControllerIsStartedResult = Result<bool, Error>;
pub type ControllerOpenExposedDirResult = Result<(), Error>;
pub type ControllerGetExposedDictionaryResult =
    Result<fdomain_fuchsia_component_sandbox::DictionaryRef, Error>;
pub type ControllerGetOutputDictionaryResult = Result<fdomain_client::EventPair, Error>;
pub type ControllerDestroyResult = Result<(), Error>;

pub trait ControllerProxyInterface: Send + Sync {
    type StartResponseFut: std::future::Future<Output = Result<ControllerStartResult, fidl::Error>>
        + Send;
    fn r#start(
        &self,
        args: StartChildArgs,
        execution_controller: fdomain_client::fidl::ServerEnd<ExecutionControllerMarker>,
    ) -> Self::StartResponseFut;
    type IsStartedResponseFut: std::future::Future<Output = Result<ControllerIsStartedResult, fidl::Error>>
        + Send;
    fn r#is_started(&self) -> Self::IsStartedResponseFut;
    type OpenExposedDirResponseFut: std::future::Future<Output = Result<ControllerOpenExposedDirResult, fidl::Error>>
        + Send;
    fn r#open_exposed_dir(
        &self,
        exposed_dir: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::DirectoryMarker>,
    ) -> Self::OpenExposedDirResponseFut;
    type GetExposedDictionaryResponseFut: std::future::Future<Output = Result<ControllerGetExposedDictionaryResult, fidl::Error>>
        + Send;
    fn r#get_exposed_dictionary(&self) -> Self::GetExposedDictionaryResponseFut;
    type GetOutputDictionaryResponseFut: std::future::Future<Output = Result<ControllerGetOutputDictionaryResult, fidl::Error>>
        + Send;
    fn r#get_output_dictionary(&self) -> Self::GetOutputDictionaryResponseFut;
    type DestroyResponseFut: std::future::Future<Output = Result<ControllerDestroyResult, fidl::Error>>
        + Send;
    fn r#destroy(&self) -> Self::DestroyResponseFut;
}

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

impl fdomain_client::fidl::Proxy for ControllerProxy {
    type Protocol = ControllerMarker;

    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 ControllerProxy {
    /// Create a new Proxy for fuchsia.component/Controller.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name = <ControllerMarker 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) -> ControllerEventStream {
        ControllerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Start the component, optionally providing additional handles to be given
    /// to the component. Returns INSTANCE_ALREADY_RUNNING if the instance is
    /// currently running.
    pub fn r#start(
        &self,
        mut args: StartChildArgs,
        mut execution_controller: fdomain_client::fidl::ServerEnd<ExecutionControllerMarker>,
    ) -> fidl::client::QueryResponseFut<
        ControllerStartResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        ControllerProxyInterface::r#start(self, args, execution_controller)
    }

    /// Returns true if this instance is currently running.
    pub fn r#is_started(
        &self,
    ) -> fidl::client::QueryResponseFut<
        ControllerIsStartedResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        ControllerProxyInterface::r#is_started(self)
    }

    /// Opens the exposed directory of the controlled component, through which
    /// capabilities the component exposed via `ComponentDecl.exposes` are
    /// available, on success.
    ///
    /// Binding to the exposed directory requires that the component be
    /// resolved, but it will not be started until/unless some capability is
    /// requested that requires it to be.
    ///
    /// If this component is destroyed, any outstanding connections to
    /// `exposed_dir` will be closed.
    ///
    /// Errors:
    /// - `INSTANCE_CANNOT_RESOLVE`: This component failed to resolve.
    pub fn r#open_exposed_dir(
        &self,
        mut exposed_dir: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::DirectoryMarker>,
    ) -> fidl::client::QueryResponseFut<
        ControllerOpenExposedDirResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        ControllerProxyInterface::r#open_exposed_dir(self, exposed_dir)
    }

    /// Returns the dictionary containing the component's exposed capabilities.
    pub fn r#get_exposed_dictionary(
        &self,
    ) -> fidl::client::QueryResponseFut<
        ControllerGetExposedDictionaryResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        ControllerProxyInterface::r#get_exposed_dictionary(self)
    }

    /// Returns a reference to the component's output dictionary, which may be
    /// interacted with by using the fuchsia.component.runtime.Capabilities API.
    pub fn r#get_output_dictionary(
        &self,
    ) -> fidl::client::QueryResponseFut<
        ControllerGetOutputDictionaryResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        ControllerProxyInterface::r#get_output_dictionary(self)
    }

    /// Destroys this component. When this method returns, the component is
    /// either destroyed or in the case of an error no destruction happened.
    ///
    /// Errors:
    ///
    /// - `ACCESS_DENIED`: Destruction of this component is not allowed.
    /// Currently, this can happen if the component is a static child of its
    /// parent.
    /// - `INTERNAL`: Something prevented destruction from succeeding -- component
    ///   manager's logs will contain more detail.
    pub fn r#destroy(
        &self,
    ) -> fidl::client::QueryResponseFut<
        ControllerDestroyResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        ControllerProxyInterface::r#destroy(self)
    }
}

impl ControllerProxyInterface for ControllerProxy {
    type StartResponseFut = fidl::client::QueryResponseFut<
        ControllerStartResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#start(
        &self,
        mut args: StartChildArgs,
        mut execution_controller: fdomain_client::fidl::ServerEnd<ExecutionControllerMarker>,
    ) -> Self::StartResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ControllerStartResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x68878076b8d2eac5,
            >(_buf?)?
            .into_result_fdomain::<ControllerMarker>("start")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<ControllerStartRequest, ControllerStartResult>(
            (&mut args, execution_controller),
            0x68878076b8d2eac5,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type IsStartedResponseFut = fidl::client::QueryResponseFut<
        ControllerIsStartedResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#is_started(&self) -> Self::IsStartedResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ControllerIsStartedResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<ControllerIsStartedResponse, Error>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x2155e6e1db2083c3,
            >(_buf?)?
            .into_result_fdomain::<ControllerMarker>("is_started")?;
            Ok(_response.map(|x| x.is_started))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, ControllerIsStartedResult>(
                (),
                0x2155e6e1db2083c3,
                fidl::encoding::DynamicFlags::FLEXIBLE,
                _decode,
            )
    }

    type OpenExposedDirResponseFut = fidl::client::QueryResponseFut<
        ControllerOpenExposedDirResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#open_exposed_dir(
        &self,
        mut exposed_dir: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::DirectoryMarker>,
    ) -> Self::OpenExposedDirResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ControllerOpenExposedDirResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x253cabb9a840ed94,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            ControllerOpenExposedDirRequest,
            ControllerOpenExposedDirResult,
        >(
            (exposed_dir,),
            0x253cabb9a840ed94,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetExposedDictionaryResponseFut = fidl::client::QueryResponseFut<
        ControllerGetExposedDictionaryResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_exposed_dictionary(&self) -> Self::GetExposedDictionaryResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ControllerGetExposedDictionaryResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<ControllerGetExposedDictionaryResponse, Error>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x7e48373e5eda1f9b,
            >(_buf?)?
            .into_result_fdomain::<ControllerMarker>("get_exposed_dictionary")?;
            Ok(_response.map(|x| x.dictionary))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            ControllerGetExposedDictionaryResult,
        >(
            (),
            0x7e48373e5eda1f9b,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type GetOutputDictionaryResponseFut = fidl::client::QueryResponseFut<
        ControllerGetOutputDictionaryResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_output_dictionary(&self) -> Self::GetOutputDictionaryResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ControllerGetOutputDictionaryResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<ControllerGetOutputDictionaryResponse, Error>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x3a0c4696620ad221,
            >(_buf?)?
            .into_result_fdomain::<ControllerMarker>("get_output_dictionary")?;
            Ok(_response.map(|x| x.dictionary))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            ControllerGetOutputDictionaryResult,
        >(
            (),
            0x3a0c4696620ad221,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type DestroyResponseFut = fidl::client::QueryResponseFut<
        ControllerDestroyResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#destroy(&self) -> Self::DestroyResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ControllerDestroyResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x74529fa68b5c1741,
            >(_buf?)?
            .into_result_fdomain::<ControllerMarker>("destroy")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ControllerDestroyResult>(
            (),
            0x74529fa68b5c1741,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for ControllerRequestStream {
    type Protocol = ControllerMarker;
    type ControlHandle = ControllerControlHandle;

    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 {
        ControllerControlHandle { 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 ControllerRequestStream {
    type Item = Result<ControllerRequest, 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 ControllerRequestStream 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 {
                    0x68878076b8d2eac5 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ControllerStartRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<ControllerStartRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ControllerControlHandle { inner: this.inner.clone() };
                        Ok(ControllerRequest::Start {
                            args: req.args,
                            execution_controller: req.execution_controller,

                            responder: ControllerStartResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2155e6e1db2083c3 => {
                        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 = ControllerControlHandle { inner: this.inner.clone() };
                        Ok(ControllerRequest::IsStarted {
                            responder: ControllerIsStartedResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x253cabb9a840ed94 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ControllerOpenExposedDirRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<ControllerOpenExposedDirRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ControllerControlHandle { inner: this.inner.clone() };
                        Ok(ControllerRequest::OpenExposedDir {
                            exposed_dir: req.exposed_dir,

                            responder: ControllerOpenExposedDirResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7e48373e5eda1f9b => {
                        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 = ControllerControlHandle { inner: this.inner.clone() };
                        Ok(ControllerRequest::GetExposedDictionary {
                            responder: ControllerGetExposedDictionaryResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3a0c4696620ad221 => {
                        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 = ControllerControlHandle { inner: this.inner.clone() };
                        Ok(ControllerRequest::GetOutputDictionary {
                            responder: ControllerGetOutputDictionaryResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x74529fa68b5c1741 => {
                        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 = ControllerControlHandle { inner: this.inner.clone() };
                        Ok(ControllerRequest::Destroy {
                            responder: ControllerDestroyResponder {
                                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(ControllerRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: ControllerControlHandle { 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(ControllerRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: ControllerControlHandle { inner: this.inner.clone() },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <ControllerMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// A protocol used to operate on a component.
///
/// One may get access to a `Controller` when creating a component with the
/// `Realm.CreateChild` method. You may also obtain a `Controller` for an
/// existing child component with the `Realm.OpenController` method.
#[derive(Debug)]
pub enum ControllerRequest {
    /// Start the component, optionally providing additional handles to be given
    /// to the component. Returns INSTANCE_ALREADY_RUNNING if the instance is
    /// currently running.
    Start {
        args: StartChildArgs,
        execution_controller: fdomain_client::fidl::ServerEnd<ExecutionControllerMarker>,
        responder: ControllerStartResponder,
    },
    /// Returns true if this instance is currently running.
    IsStarted { responder: ControllerIsStartedResponder },
    /// Opens the exposed directory of the controlled component, through which
    /// capabilities the component exposed via `ComponentDecl.exposes` are
    /// available, on success.
    ///
    /// Binding to the exposed directory requires that the component be
    /// resolved, but it will not be started until/unless some capability is
    /// requested that requires it to be.
    ///
    /// If this component is destroyed, any outstanding connections to
    /// `exposed_dir` will be closed.
    ///
    /// Errors:
    /// - `INSTANCE_CANNOT_RESOLVE`: This component failed to resolve.
    OpenExposedDir {
        exposed_dir: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::DirectoryMarker>,
        responder: ControllerOpenExposedDirResponder,
    },
    /// Returns the dictionary containing the component's exposed capabilities.
    GetExposedDictionary { responder: ControllerGetExposedDictionaryResponder },
    /// Returns a reference to the component's output dictionary, which may be
    /// interacted with by using the fuchsia.component.runtime.Capabilities API.
    GetOutputDictionary { responder: ControllerGetOutputDictionaryResponder },
    /// Destroys this component. When this method returns, the component is
    /// either destroyed or in the case of an error no destruction happened.
    ///
    /// Errors:
    ///
    /// - `ACCESS_DENIED`: Destruction of this component is not allowed.
    /// Currently, this can happen if the component is a static child of its
    /// parent.
    /// - `INTERNAL`: Something prevented destruction from succeeding -- component
    ///   manager's logs will contain more detail.
    Destroy { responder: ControllerDestroyResponder },
    /// 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: ControllerControlHandle,
        method_type: fidl::MethodType,
    },
}

impl ControllerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_start(
        self,
    ) -> Option<(
        StartChildArgs,
        fdomain_client::fidl::ServerEnd<ExecutionControllerMarker>,
        ControllerStartResponder,
    )> {
        if let ControllerRequest::Start { args, execution_controller, responder } = self {
            Some((args, execution_controller, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_is_started(self) -> Option<(ControllerIsStartedResponder)> {
        if let ControllerRequest::IsStarted { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_open_exposed_dir(
        self,
    ) -> Option<(
        fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::DirectoryMarker>,
        ControllerOpenExposedDirResponder,
    )> {
        if let ControllerRequest::OpenExposedDir { exposed_dir, responder } = self {
            Some((exposed_dir, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_exposed_dictionary(self) -> Option<(ControllerGetExposedDictionaryResponder)> {
        if let ControllerRequest::GetExposedDictionary { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_output_dictionary(self) -> Option<(ControllerGetOutputDictionaryResponder)> {
        if let ControllerRequest::GetOutputDictionary { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_destroy(self) -> Option<(ControllerDestroyResponder)> {
        if let ControllerRequest::Destroy { responder } = self { Some((responder)) } else { None }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            ControllerRequest::Start { .. } => "start",
            ControllerRequest::IsStarted { .. } => "is_started",
            ControllerRequest::OpenExposedDir { .. } => "open_exposed_dir",
            ControllerRequest::GetExposedDictionary { .. } => "get_exposed_dictionary",
            ControllerRequest::GetOutputDictionary { .. } => "get_output_dictionary",
            ControllerRequest::Destroy { .. } => "destroy",
            ControllerRequest::_UnknownMethod { method_type: fidl::MethodType::OneWay, .. } => {
                "unknown one-way method"
            }
            ControllerRequest::_UnknownMethod { method_type: fidl::MethodType::TwoWay, .. } => {
                "unknown two-way method"
            }
        }
    }
}

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

impl fdomain_client::fidl::ControlHandle for ControllerControlHandle {
    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 ControllerControlHandle {}

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

/// Set the the channel to be shutdown (see [`ControllerControlHandle::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 ControllerStartResponder {
    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 ControllerStartResponder {
    type ControlHandle = ControllerControlHandle;

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

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

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

/// Set the the channel to be shutdown (see [`ControllerControlHandle::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 ControllerIsStartedResponder {
    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 ControllerIsStartedResponder {
    type ControlHandle = ControllerControlHandle;

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

    fn send_raw(&self, mut result: Result<bool, Error>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
            ControllerIsStartedResponse,
            Error,
        >>(
            fidl::encoding::FlexibleResult::new(result.map(|is_started| (is_started,))),
            self.tx_id,
            0x2155e6e1db2083c3,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

/// Set the the channel to be shutdown (see [`ControllerControlHandle::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 ControllerOpenExposedDirResponder {
    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 ControllerOpenExposedDirResponder {
    type ControlHandle = ControllerControlHandle;

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

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

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

/// Set the the channel to be shutdown (see [`ControllerControlHandle::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 ControllerGetExposedDictionaryResponder {
    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 ControllerGetExposedDictionaryResponder {
    type ControlHandle = ControllerControlHandle;

    fn control_handle(&self) -> &ControllerControlHandle {
        &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 ControllerGetExposedDictionaryResponder {
    /// 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_sandbox::DictionaryRef, 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_sandbox::DictionaryRef, 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_sandbox::DictionaryRef, Error>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
            ControllerGetExposedDictionaryResponse,
            Error,
        >>(
            fidl::encoding::FlexibleResult::new(
                result.as_mut().map_err(|e| *e).map(|dictionary| (dictionary,)),
            ),
            self.tx_id,
            0x7e48373e5eda1f9b,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

/// Set the the channel to be shutdown (see [`ControllerControlHandle::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 ControllerGetOutputDictionaryResponder {
    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 ControllerGetOutputDictionaryResponder {
    type ControlHandle = ControllerControlHandle;

    fn control_handle(&self) -> &ControllerControlHandle {
        &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 ControllerGetOutputDictionaryResponder {
    /// 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::EventPair, 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_client::EventPair, Error>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<fdomain_client::EventPair, Error>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
            ControllerGetOutputDictionaryResponse,
            Error,
        >>(
            fidl::encoding::FlexibleResult::new(result.map(|dictionary| (dictionary,))),
            self.tx_id,
            0x3a0c4696620ad221,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

/// Set the the channel to be shutdown (see [`ControllerControlHandle::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 ControllerDestroyResponder {
    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 ControllerDestroyResponder {
    type ControlHandle = ControllerControlHandle;

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

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

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

impl fdomain_client::fidl::ProtocolMarker for EventStreamMarker {
    type Proxy = EventStreamProxy;
    type RequestStream = EventStreamRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.component.EventStream";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for EventStreamMarker {}

pub trait EventStreamProxyInterface: Send + Sync {
    type GetNextResponseFut: std::future::Future<Output = Result<Vec<Event>, fidl::Error>> + Send;
    fn r#get_next(&self) -> Self::GetNextResponseFut;
    type WaitForReadyResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#wait_for_ready(&self) -> Self::WaitForReadyResponseFut;
}

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

impl fdomain_client::fidl::Proxy for EventStreamProxy {
    type Protocol = EventStreamMarker;

    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 EventStreamProxy {
    /// Create a new Proxy for fuchsia.component/EventStream.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name = <EventStreamMarker 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) -> EventStreamEventStream {
        EventStreamEventStream { event_receiver: self.client.take_event_receiver() }
    }

    pub fn r#get_next(
        &self,
    ) -> fidl::client::QueryResponseFut<Vec<Event>, fdomain_client::fidl::FDomainResourceDialect>
    {
        EventStreamProxyInterface::r#get_next(self)
    }

    /// Returns immediately. Used to indicate that the FIDL connection
    /// completed. This is needed for non-static streams to verify
    /// that subscribe has completed before components are started.
    pub fn r#wait_for_ready(
        &self,
    ) -> fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect> {
        EventStreamProxyInterface::r#wait_for_ready(self)
    }
}

impl EventStreamProxyInterface for EventStreamProxy {
    type GetNextResponseFut =
        fidl::client::QueryResponseFut<Vec<Event>, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#get_next(&self) -> Self::GetNextResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<Event>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                EventStreamGetNextResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x3f24c9495978eb86,
            >(_buf?)?;
            Ok(_response.events)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<Event>>(
            (),
            0x3f24c9495978eb86,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type WaitForReadyResponseFut =
        fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect>;
    fn r#wait_for_ready(&self) -> Self::WaitForReadyResponseFut {
        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,
                0x31331f9578d2e682,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
            (),
            0x31331f9578d2e682,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for EventStreamRequestStream {
    type Protocol = EventStreamMarker;
    type ControlHandle = EventStreamControlHandle;

    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 {
        EventStreamControlHandle { 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 EventStreamRequestStream {
    type Item = Result<EventStreamRequest, 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 EventStreamRequestStream 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 {
                    0x3f24c9495978eb86 => {
                        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 = EventStreamControlHandle { inner: this.inner.clone() };
                        Ok(EventStreamRequest::GetNext {
                            responder: EventStreamGetNextResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x31331f9578d2e682 => {
                        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 = EventStreamControlHandle { inner: this.inner.clone() };
                        Ok(EventStreamRequest::WaitForReady {
                            responder: EventStreamWaitForReadyResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <EventStreamMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Listener for events on the component hierarchy.
/// Can't be used outside of the platform.
#[derive(Debug)]
pub enum EventStreamRequest {
    GetNext {
        responder: EventStreamGetNextResponder,
    },
    /// Returns immediately. Used to indicate that the FIDL connection
    /// completed. This is needed for non-static streams to verify
    /// that subscribe has completed before components are started.
    WaitForReady {
        responder: EventStreamWaitForReadyResponder,
    },
}

impl EventStreamRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_next(self) -> Option<(EventStreamGetNextResponder)> {
        if let EventStreamRequest::GetNext { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_wait_for_ready(self) -> Option<(EventStreamWaitForReadyResponder)> {
        if let EventStreamRequest::WaitForReady { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            EventStreamRequest::GetNext { .. } => "get_next",
            EventStreamRequest::WaitForReady { .. } => "wait_for_ready",
        }
    }
}

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

impl fdomain_client::fidl::ControlHandle for EventStreamControlHandle {
    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 EventStreamControlHandle {}

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

/// Set the the channel to be shutdown (see [`EventStreamControlHandle::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 EventStreamGetNextResponder {
    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 EventStreamGetNextResponder {
    type ControlHandle = EventStreamControlHandle;

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

    fn send_raw(&self, mut events: Vec<Event>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<EventStreamGetNextResponse>(
            (events.as_mut(),),
            self.tx_id,
            0x3f24c9495978eb86,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`EventStreamControlHandle::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 EventStreamWaitForReadyResponder {
    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 EventStreamWaitForReadyResponder {
    type ControlHandle = EventStreamControlHandle;

    fn control_handle(&self) -> &EventStreamControlHandle {
        &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 EventStreamWaitForReadyResponder {
    /// 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,
            0x31331f9578d2e682,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fdomain_client::fidl::ProtocolMarker for ExecutionControllerMarker {
    type Proxy = ExecutionControllerProxy;
    type RequestStream = ExecutionControllerRequestStream;

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

pub trait ExecutionControllerProxyInterface: Send + Sync {
    fn r#stop(&self) -> Result<(), fidl::Error>;
}

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

impl fdomain_client::fidl::Proxy for ExecutionControllerProxy {
    type Protocol = ExecutionControllerMarker;

    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 ExecutionControllerProxy {
    /// Create a new Proxy for fuchsia.component/ExecutionController.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name =
            <ExecutionControllerMarker 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) -> ExecutionControllerEventStream {
        ExecutionControllerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Initiates a stop action on this component. Once complete, OnStop will be
    /// called with the stopped payload and this channel is closed.
    ///
    /// Note that a component may stop running on its own at any time, so it is
    /// possible for `OnStop` to be received before `Stop` is called.
    pub fn r#stop(&self) -> Result<(), fidl::Error> {
        ExecutionControllerProxyInterface::r#stop(self)
    }
}

impl ExecutionControllerProxyInterface for ExecutionControllerProxy {
    fn r#stop(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x56d23cec21036117,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

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

impl ExecutionControllerEvent {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_stop(self) -> Option<StoppedPayload> {
        if let ExecutionControllerEvent::OnStop { stopped_payload } = self {
            Some((stopped_payload))
        } else {
            None
        }
    }

    /// Decodes a message buffer as a [`ExecutionControllerEvent`].
    fn decode(
        mut buf: <fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<ExecutionControllerEvent, 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 {
            0x62d5018e2174f57f => {
                let mut out = fidl::new_empty!(
                    ExecutionControllerOnStopRequest,
                    fdomain_client::fidl::FDomainResourceDialect
                );
                fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<ExecutionControllerOnStopRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((ExecutionControllerEvent::OnStop { stopped_payload: out.stopped_payload }))
            }
            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                Ok(ExecutionControllerEvent::_UnknownEvent { ordinal: tx_header.ordinal })
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name:
                    <ExecutionControllerMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fdomain_client::fidl::RequestStream for ExecutionControllerRequestStream {
    type Protocol = ExecutionControllerMarker;
    type ControlHandle = ExecutionControllerControlHandle;

    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 {
        ExecutionControllerControlHandle { 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 ExecutionControllerRequestStream {
    type Item = Result<ExecutionControllerRequest, 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 ExecutionControllerRequestStream 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 {
                0x56d23cec21036117 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    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 = ExecutionControllerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(ExecutionControllerRequest::Stop {
                        control_handle,
                    })
                }
                _ if header.tx_id == 0 && header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                    Ok(ExecutionControllerRequest::_UnknownMethod {
                        ordinal: header.ordinal,
                        control_handle: ExecutionControllerControlHandle { 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(ExecutionControllerRequest::_UnknownMethod {
                        ordinal: header.ordinal,
                        control_handle: ExecutionControllerControlHandle { inner: this.inner.clone() },
                        method_type: fidl::MethodType::TwoWay,
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <ExecutionControllerMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

#[derive(Debug)]
pub enum ExecutionControllerRequest {
    /// Initiates a stop action on this component. Once complete, OnStop will be
    /// called with the stopped payload and this channel is closed.
    ///
    /// Note that a component may stop running on its own at any time, so it is
    /// possible for `OnStop` to be received before `Stop` is called.
    Stop { control_handle: ExecutionControllerControlHandle },
    /// 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: ExecutionControllerControlHandle,
        method_type: fidl::MethodType,
    },
}

impl ExecutionControllerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_stop(self) -> Option<(ExecutionControllerControlHandle)> {
        if let ExecutionControllerRequest::Stop { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

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

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

impl fdomain_client::fidl::ControlHandle for ExecutionControllerControlHandle {
    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 ExecutionControllerControlHandle {
    pub fn send_on_stop(&self, mut stopped_payload: &StoppedPayload) -> Result<(), fidl::Error> {
        self.inner.send::<ExecutionControllerOnStopRequest>(
            (stopped_payload,),
            0,
            0x62d5018e2174f57f,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

impl fdomain_client::fidl::ProtocolMarker for IntrospectorMarker {
    type Proxy = IntrospectorProxy;
    type RequestStream = IntrospectorRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.component.Introspector";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for IntrospectorMarker {}
pub type IntrospectorGetMonikerResult = Result<String, Error>;

pub trait IntrospectorProxyInterface: Send + Sync {
    type GetMonikerResponseFut: std::future::Future<Output = Result<IntrospectorGetMonikerResult, fidl::Error>>
        + Send;
    fn r#get_moniker(
        &self,
        component_instance: fdomain_client::Event,
    ) -> Self::GetMonikerResponseFut;
}

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

impl fdomain_client::fidl::Proxy for IntrospectorProxy {
    type Protocol = IntrospectorMarker;

    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 IntrospectorProxy {
    /// Create a new Proxy for fuchsia.component/Introspector.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name =
            <IntrospectorMarker 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) -> IntrospectorEventStream {
        IntrospectorEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Obtains the moniker relative to this realm of the component
    /// corresponding to the provided token. Runners may obtain the token via
    /// `fuchsia.component.runner/ComponentStartInfo.component_instance`.
    ///
    /// Returns `Error.INSTANCE_NOT_FOUND` if the token is invalid, or
    /// does not correspond to a component under this realm.
    pub fn r#get_moniker(
        &self,
        mut component_instance: fdomain_client::Event,
    ) -> fidl::client::QueryResponseFut<
        IntrospectorGetMonikerResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        IntrospectorProxyInterface::r#get_moniker(self, component_instance)
    }
}

impl IntrospectorProxyInterface for IntrospectorProxy {
    type GetMonikerResponseFut = fidl::client::QueryResponseFut<
        IntrospectorGetMonikerResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_moniker(
        &self,
        mut component_instance: fdomain_client::Event,
    ) -> Self::GetMonikerResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<IntrospectorGetMonikerResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<IntrospectorGetMonikerResponse, Error>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x2f980ceb37bf458,
            >(_buf?)?
            .into_result_fdomain::<IntrospectorMarker>("get_moniker")?;
            Ok(_response.map(|x| x.moniker))
        }
        self.client
            .send_query_and_decode::<IntrospectorGetMonikerRequest, IntrospectorGetMonikerResult>(
                (component_instance,),
                0x2f980ceb37bf458,
                fidl::encoding::DynamicFlags::FLEXIBLE,
                _decode,
            )
    }
}

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for IntrospectorRequestStream {
    type Protocol = IntrospectorMarker;
    type ControlHandle = IntrospectorControlHandle;

    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 {
        IntrospectorControlHandle { 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 IntrospectorRequestStream {
    type Item = Result<IntrospectorRequest, 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 IntrospectorRequestStream 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 {
                    0x2f980ceb37bf458 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            IntrospectorGetMonikerRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<IntrospectorGetMonikerRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            IntrospectorControlHandle { inner: this.inner.clone() };
                        Ok(IntrospectorRequest::GetMoniker {
                            component_instance: req.component_instance,

                            responder: IntrospectorGetMonikerResponder {
                                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(IntrospectorRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: IntrospectorControlHandle { 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(IntrospectorRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: IntrospectorControlHandle { inner: this.inner.clone() },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <IntrospectorMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// A protocol used by a component instance to obtain information about
/// components in its own realm.
///
/// This protocol only supports getting the moniker at the moment but could
/// expand to other privileged information such as the URL of a component.
///
/// The component framework provides this capability to components that use
/// `fuchsia.component.Introspector` from framework.
#[derive(Debug)]
pub enum IntrospectorRequest {
    /// Obtains the moniker relative to this realm of the component
    /// corresponding to the provided token. Runners may obtain the token via
    /// `fuchsia.component.runner/ComponentStartInfo.component_instance`.
    ///
    /// Returns `Error.INSTANCE_NOT_FOUND` if the token is invalid, or
    /// does not correspond to a component under this realm.
    GetMoniker {
        component_instance: fdomain_client::Event,
        responder: IntrospectorGetMonikerResponder,
    },
    /// 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: IntrospectorControlHandle,
        method_type: fidl::MethodType,
    },
}

impl IntrospectorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_moniker(
        self,
    ) -> Option<(fdomain_client::Event, IntrospectorGetMonikerResponder)> {
        if let IntrospectorRequest::GetMoniker { component_instance, responder } = self {
            Some((component_instance, responder))
        } else {
            None
        }
    }

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

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

impl fdomain_client::fidl::ControlHandle for IntrospectorControlHandle {
    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 IntrospectorControlHandle {}

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

/// Set the the channel to be shutdown (see [`IntrospectorControlHandle::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 IntrospectorGetMonikerResponder {
    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 IntrospectorGetMonikerResponder {
    type ControlHandle = IntrospectorControlHandle;

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

    fn send_raw(&self, mut result: Result<&str, Error>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
            IntrospectorGetMonikerResponse,
            Error,
        >>(
            fidl::encoding::FlexibleResult::new(result.map(|moniker| (moniker,))),
            self.tx_id,
            0x2f980ceb37bf458,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

impl fdomain_client::fidl::ProtocolMarker for NamespaceMarker {
    type Proxy = NamespaceProxy;
    type RequestStream = NamespaceRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.component.Namespace";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for NamespaceMarker {}
pub type NamespaceCreateResult = Result<Vec<NamespaceEntry>, NamespaceError>;
pub type NamespaceCreate2Result = Result<Vec<NamespaceEntry>, NamespaceError>;

pub trait NamespaceProxyInterface: Send + Sync {
    type CreateResponseFut: std::future::Future<Output = Result<NamespaceCreateResult, fidl::Error>>
        + Send;
    fn r#create(&self, entries: Vec<NamespaceInputEntry>) -> Self::CreateResponseFut;
    type Create2ResponseFut: std::future::Future<Output = Result<NamespaceCreate2Result, fidl::Error>>
        + Send;
    fn r#create2(&self, entries: Vec<NamespaceInputEntry2>) -> Self::Create2ResponseFut;
}

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

impl fdomain_client::fidl::Proxy for NamespaceProxy {
    type Protocol = NamespaceMarker;

    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 NamespaceProxy {
    /// Create a new Proxy for fuchsia.component/Namespace.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name = <NamespaceMarker 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) -> NamespaceEventStream {
        NamespaceEventStream { event_receiver: self.client.take_event_receiver() }
    }

    pub fn r#create(
        &self,
        mut entries: Vec<NamespaceInputEntry>,
    ) -> fidl::client::QueryResponseFut<
        NamespaceCreateResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        NamespaceProxyInterface::r#create(self, entries)
    }

    pub fn r#create2(
        &self,
        mut entries: Vec<NamespaceInputEntry2>,
    ) -> fidl::client::QueryResponseFut<
        NamespaceCreate2Result,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        NamespaceProxyInterface::r#create2(self, entries)
    }
}

impl NamespaceProxyInterface for NamespaceProxy {
    type CreateResponseFut = fidl::client::QueryResponseFut<
        NamespaceCreateResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#create(&self, mut entries: Vec<NamespaceInputEntry>) -> Self::CreateResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NamespaceCreateResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<NamespaceCreateResponse, NamespaceError>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x4329fe12b2a790f9,
            >(_buf?)?
            .into_result_fdomain::<NamespaceMarker>("create")?;
            Ok(_response.map(|x| x.entries))
        }
        self.client.send_query_and_decode::<NamespaceCreateRequest, NamespaceCreateResult>(
            (entries.as_mut(),),
            0x4329fe12b2a790f9,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type Create2ResponseFut = fidl::client::QueryResponseFut<
        NamespaceCreate2Result,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#create2(&self, mut entries: Vec<NamespaceInputEntry2>) -> Self::Create2ResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NamespaceCreate2Result, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<NamespaceCreate2Response, NamespaceError>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x665aa4bb3773b351,
            >(_buf?)?
            .into_result_fdomain::<NamespaceMarker>("create2")?;
            Ok(_response.map(|x| x.entries))
        }
        self.client.send_query_and_decode::<NamespaceCreate2Request, NamespaceCreate2Result>(
            (entries.as_mut(),),
            0x665aa4bb3773b351,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for NamespaceRequestStream {
    type Protocol = NamespaceMarker;
    type ControlHandle = NamespaceControlHandle;

    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 {
        NamespaceControlHandle { 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 NamespaceRequestStream {
    type Item = Result<NamespaceRequest, 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 NamespaceRequestStream 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 {
                    0x4329fe12b2a790f9 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NamespaceCreateRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NamespaceCreateRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = NamespaceControlHandle { inner: this.inner.clone() };
                        Ok(NamespaceRequest::Create {
                            entries: req.entries,

                            responder: NamespaceCreateResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x665aa4bb3773b351 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NamespaceCreate2Request,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<NamespaceCreate2Request>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = NamespaceControlHandle { inner: this.inner.clone() };
                        Ok(NamespaceRequest::Create2 {
                            entries: req.entries,

                            responder: NamespaceCreate2Responder {
                                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(NamespaceRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: NamespaceControlHandle { 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(NamespaceRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: NamespaceControlHandle { inner: this.inner.clone() },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <NamespaceMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Protocol for performing namespace operations.
#[derive(Debug)]
pub enum NamespaceRequest {
    Create {
        entries: Vec<NamespaceInputEntry>,
        responder: NamespaceCreateResponder,
    },
    Create2 {
        entries: Vec<NamespaceInputEntry2>,
        responder: NamespaceCreate2Responder,
    },
    /// 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: NamespaceControlHandle,
        method_type: fidl::MethodType,
    },
}

impl NamespaceRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_create(self) -> Option<(Vec<NamespaceInputEntry>, NamespaceCreateResponder)> {
        if let NamespaceRequest::Create { entries, responder } = self {
            Some((entries, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_create2(self) -> Option<(Vec<NamespaceInputEntry2>, NamespaceCreate2Responder)> {
        if let NamespaceRequest::Create2 { entries, responder } = self {
            Some((entries, responder))
        } else {
            None
        }
    }

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

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

impl fdomain_client::fidl::ControlHandle for NamespaceControlHandle {
    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 NamespaceControlHandle {}

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

/// Set the the channel to be shutdown (see [`NamespaceControlHandle::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 NamespaceCreateResponder {
    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 NamespaceCreateResponder {
    type ControlHandle = NamespaceControlHandle;

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

    fn send_raw(
        &self,
        mut result: Result<Vec<NamespaceEntry>, NamespaceError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
            NamespaceCreateResponse,
            NamespaceError,
        >>(
            fidl::encoding::FlexibleResult::new(
                result.as_mut().map_err(|e| *e).map(|entries| (entries.as_mut_slice(),)),
            ),
            self.tx_id,
            0x4329fe12b2a790f9,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

/// Set the the channel to be shutdown (see [`NamespaceControlHandle::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 NamespaceCreate2Responder {
    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 NamespaceCreate2Responder {
    type ControlHandle = NamespaceControlHandle;

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

    fn send_raw(
        &self,
        mut result: Result<Vec<NamespaceEntry>, NamespaceError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
            NamespaceCreate2Response,
            NamespaceError,
        >>(
            fidl::encoding::FlexibleResult::new(
                result.as_mut().map_err(|e| *e).map(|entries| (entries.as_mut_slice(),)),
            ),
            self.tx_id,
            0x665aa4bb3773b351,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

impl fdomain_client::fidl::ProtocolMarker for RealmMarker {
    type Proxy = RealmProxy;
    type RequestStream = RealmRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.component.Realm";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for RealmMarker {}
pub type RealmOpenControllerResult = Result<(), Error>;
pub type RealmOpenExposedDirResult = Result<(), Error>;
pub type RealmCreateChildResult = Result<(), Error>;
pub type RealmDestroyChildResult = Result<(), Error>;
pub type RealmListChildrenResult = Result<(), Error>;
pub type RealmGetResolvedInfoResult =
    Result<fdomain_fuchsia_component_resolution::Component, Error>;
pub type RealmGetChildOutputDictionaryDeprecatedResult =
    Result<fdomain_fuchsia_component_sandbox::DictionaryRef, Error>;
pub type RealmGetChildOutputDictionaryResult = Result<fdomain_client::EventPair, Error>;

pub trait RealmProxyInterface: Send + Sync {
    type OpenControllerResponseFut: std::future::Future<Output = Result<RealmOpenControllerResult, fidl::Error>>
        + Send;
    fn r#open_controller(
        &self,
        child: &fdomain_fuchsia_component_decl::ChildRef,
        controller: fdomain_client::fidl::ServerEnd<ControllerMarker>,
    ) -> Self::OpenControllerResponseFut;
    type OpenExposedDirResponseFut: std::future::Future<Output = Result<RealmOpenExposedDirResult, fidl::Error>>
        + Send;
    fn r#open_exposed_dir(
        &self,
        child: &fdomain_fuchsia_component_decl::ChildRef,
        exposed_dir: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::DirectoryMarker>,
    ) -> Self::OpenExposedDirResponseFut;
    type CreateChildResponseFut: std::future::Future<Output = Result<RealmCreateChildResult, fidl::Error>>
        + Send;
    fn r#create_child(
        &self,
        collection: &fdomain_fuchsia_component_decl::CollectionRef,
        decl: &fdomain_fuchsia_component_decl::Child,
        args: CreateChildArgs,
    ) -> Self::CreateChildResponseFut;
    type DestroyChildResponseFut: std::future::Future<Output = Result<RealmDestroyChildResult, fidl::Error>>
        + Send;
    fn r#destroy_child(
        &self,
        child: &fdomain_fuchsia_component_decl::ChildRef,
    ) -> Self::DestroyChildResponseFut;
    type ListChildrenResponseFut: std::future::Future<Output = Result<RealmListChildrenResult, fidl::Error>>
        + Send;
    fn r#list_children(
        &self,
        collection: &fdomain_fuchsia_component_decl::CollectionRef,
        iter: fdomain_client::fidl::ServerEnd<ChildIteratorMarker>,
    ) -> Self::ListChildrenResponseFut;
    type GetResolvedInfoResponseFut: std::future::Future<Output = Result<RealmGetResolvedInfoResult, fidl::Error>>
        + Send;
    fn r#get_resolved_info(&self) -> Self::GetResolvedInfoResponseFut;
    type GetChildOutputDictionaryDeprecatedResponseFut: std::future::Future<
            Output = Result<RealmGetChildOutputDictionaryDeprecatedResult, fidl::Error>,
        > + Send;
    fn r#get_child_output_dictionary_deprecated(
        &self,
        child: &fdomain_fuchsia_component_decl::ChildRef,
    ) -> Self::GetChildOutputDictionaryDeprecatedResponseFut;
    type GetChildOutputDictionaryResponseFut: std::future::Future<Output = Result<RealmGetChildOutputDictionaryResult, fidl::Error>>
        + Send;
    fn r#get_child_output_dictionary(
        &self,
        child: &fdomain_fuchsia_component_decl::ChildRef,
    ) -> Self::GetChildOutputDictionaryResponseFut;
}

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

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

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

    /// Operate on a child component. See documentation for [`Controller`].
    ///
    /// Errors:
    /// - `INVALID_ARGUMENTS`: `child` is not a valid child reference.
    /// - `INSTANCE_NOT_FOUND`: `child` does not exist.
    /// - `INSTANCE_DIED`: This realm no longer exists.
    pub fn r#open_controller(
        &self,
        mut child: &fdomain_fuchsia_component_decl::ChildRef,
        mut controller: fdomain_client::fidl::ServerEnd<ControllerMarker>,
    ) -> fidl::client::QueryResponseFut<
        RealmOpenControllerResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        RealmProxyInterface::r#open_controller(self, child, controller)
    }

    /// Opens the exposed directory of a child component. When this function
    /// successfully returns, `exposed_dir` is bound to a directory that
    /// contains the capabilities which the child exposed to its realm via
    /// `ComponentDecl.exposes` (specified via "expose" declarations in the
    /// component's manifest). The child component will not start as a result of
    /// this call.
    ///
    /// `exposed_dir` is open as long as `child` exists.
    ///
    /// Errors:
    /// - `INVALID_ARGUMENTS`: `child` is not a valid child reference.
    /// - `INSTANCE_NOT_FOUND`: `child` does not exist.
    /// - `INSTANCE_CANNOT_RESOLVE`: `child`'s component declaration failed to resolve.
    /// - `INSTANCE_DIED`: This realm no longer exists.
    pub fn r#open_exposed_dir(
        &self,
        mut child: &fdomain_fuchsia_component_decl::ChildRef,
        mut exposed_dir: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::DirectoryMarker>,
    ) -> fidl::client::QueryResponseFut<
        RealmOpenExposedDirResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        RealmProxyInterface::r#open_exposed_dir(self, child, exposed_dir)
    }

    /// Creates a child component instance dynamically. When this function
    /// returns successfully, the instance exists, but it may not be running.
    ///
    /// The environment of the child instance is determined by the environment
    /// of the collection. `decl` must not set `environment`.
    ///
    /// If `decl.startup == EAGER`, or `collection.durability == SINGLE_RUN`,
    /// [CreateChild] will start the component and return once the component is
    /// started. Otherwise, [CreateChild] will return immediately after creating
    /// the component and will not start or resolve it.
    ///
    /// Errors:
    /// - `INVALID_ARGUMENTS`: `collection` is not a valid reference or `child`
    ///   is not a valid declaration.
    /// - `COLLECTION_NOT_FOUND`: `collection` does not exist.
    /// - `INSTANCE_ALREADY_EXISTS`: `decl.name` already exists in `collection`.
    /// - `INSTANCE_CANNOT_RESOLVE`: `child`'s component declaration failed to resolve
    ///   in a `SingleRun` collection.
    /// - `NO_SPACE`: Could not allocate storage for the new instance.
    /// - `INSTANCE_DIED`: This realm no longer exists.
    pub fn r#create_child(
        &self,
        mut collection: &fdomain_fuchsia_component_decl::CollectionRef,
        mut decl: &fdomain_fuchsia_component_decl::Child,
        mut args: CreateChildArgs,
    ) -> fidl::client::QueryResponseFut<
        RealmCreateChildResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        RealmProxyInterface::r#create_child(self, collection, decl, args)
    }

    /// Destroys a dynamically-created component instance. When this function
    /// returns, the instance is destroyed and has stopped running.  However,
    /// cleanup of the component's resources (such as its isolated storage) may
    /// happen in the background after this function returns.
    ///
    /// Errors:
    /// - `INVALID_ARGUMENTS`: `child` is not a valid reference or does not refer
    ///   to a dynamic instance.
    /// - `INSTANCE_NOT_FOUND`: `child` does not exist.
    /// - `COLLECTION_NOT_FOUND`: `collection` does not exist.
    /// - `INSTANCE_DIED`: This realm no longer exists.
    pub fn r#destroy_child(
        &self,
        mut child: &fdomain_fuchsia_component_decl::ChildRef,
    ) -> fidl::client::QueryResponseFut<
        RealmDestroyChildResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        RealmProxyInterface::r#destroy_child(self, child)
    }

    /// Returns an iterator that lists all instances in a collection.
    ///
    /// NOTE: The results are not guaranteed to be consistent. Instances may be
    /// created or destroyed while the iterator is live, but those changes
    /// won't be observed by the iterator after this method returns.
    ///
    /// Errors:
    /// - `INVALID_ARGUMENTS`: `collection` is not a valid reference or `iter`
    /// does not have `ZX_RIGHT_WAIT`.
    /// - `COLLECTION_NOT_FOUND`: `collection` does not exist.
    /// - `INSTANCE_DIED`: This realm no longer exists.
    /// - If `iter` does not have standard channel rights, this function may
    ///   return `ACCESS_DENIED` or component manager may close `iter`.
    pub fn r#list_children(
        &self,
        mut collection: &fdomain_fuchsia_component_decl::CollectionRef,
        mut iter: fdomain_client::fidl::ServerEnd<ChildIteratorMarker>,
    ) -> fidl::client::QueryResponseFut<
        RealmListChildrenResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        RealmProxyInterface::r#list_children(self, collection, iter)
    }

    /// Returns the set of information that was given to the component framework
    /// by this component's resolver.
    pub fn r#get_resolved_info(
        &self,
    ) -> fidl::client::QueryResponseFut<
        RealmGetResolvedInfoResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        RealmProxyInterface::r#get_resolved_info(self)
    }

    pub fn r#get_child_output_dictionary_deprecated(
        &self,
        mut child: &fdomain_fuchsia_component_decl::ChildRef,
    ) -> fidl::client::QueryResponseFut<
        RealmGetChildOutputDictionaryDeprecatedResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        RealmProxyInterface::r#get_child_output_dictionary_deprecated(self, child)
    }

    /// Returns a reference to a child's output dictionary, which may be
    /// interacted with by using the fuchsia.component.runtime.Capabilities API.
    pub fn r#get_child_output_dictionary(
        &self,
        mut child: &fdomain_fuchsia_component_decl::ChildRef,
    ) -> fidl::client::QueryResponseFut<
        RealmGetChildOutputDictionaryResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        RealmProxyInterface::r#get_child_output_dictionary(self, child)
    }
}

impl RealmProxyInterface for RealmProxy {
    type OpenControllerResponseFut = fidl::client::QueryResponseFut<
        RealmOpenControllerResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#open_controller(
        &self,
        mut child: &fdomain_fuchsia_component_decl::ChildRef,
        mut controller: fdomain_client::fidl::ServerEnd<ControllerMarker>,
    ) -> Self::OpenControllerResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RealmOpenControllerResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x7150b7898d1b1180,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<RealmOpenControllerRequest, RealmOpenControllerResult>(
            (child, controller),
            0x7150b7898d1b1180,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type OpenExposedDirResponseFut = fidl::client::QueryResponseFut<
        RealmOpenExposedDirResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#open_exposed_dir(
        &self,
        mut child: &fdomain_fuchsia_component_decl::ChildRef,
        mut exposed_dir: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::DirectoryMarker>,
    ) -> Self::OpenExposedDirResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RealmOpenExposedDirResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x7f993235ca59f92c,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<RealmOpenExposedDirRequest, RealmOpenExposedDirResult>(
            (child, exposed_dir),
            0x7f993235ca59f92c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type CreateChildResponseFut = fidl::client::QueryResponseFut<
        RealmCreateChildResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#create_child(
        &self,
        mut collection: &fdomain_fuchsia_component_decl::CollectionRef,
        mut decl: &fdomain_fuchsia_component_decl::Child,
        mut args: CreateChildArgs,
    ) -> Self::CreateChildResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RealmCreateChildResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x43e48ce8483d7560,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<RealmCreateChildRequest, RealmCreateChildResult>(
            (collection, decl, &mut args),
            0x43e48ce8483d7560,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type DestroyChildResponseFut = fidl::client::QueryResponseFut<
        RealmDestroyChildResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#destroy_child(
        &self,
        mut child: &fdomain_fuchsia_component_decl::ChildRef,
    ) -> Self::DestroyChildResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RealmDestroyChildResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x71d8caf8850c9222,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<RealmDestroyChildRequest, RealmDestroyChildResult>(
            (child,),
            0x71d8caf8850c9222,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ListChildrenResponseFut = fidl::client::QueryResponseFut<
        RealmListChildrenResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#list_children(
        &self,
        mut collection: &fdomain_fuchsia_component_decl::CollectionRef,
        mut iter: fdomain_client::fidl::ServerEnd<ChildIteratorMarker>,
    ) -> Self::ListChildrenResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RealmListChildrenResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x6888a76683efc0a1,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<RealmListChildrenRequest, RealmListChildrenResult>(
            (collection, iter),
            0x6888a76683efc0a1,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetResolvedInfoResponseFut = fidl::client::QueryResponseFut<
        RealmGetResolvedInfoResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_resolved_info(&self) -> Self::GetResolvedInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RealmGetResolvedInfoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<RealmGetResolvedInfoResponse, Error>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x734f744cb7d210a2,
            >(_buf?)?;
            Ok(_response.map(|x| x.resolved_info))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, RealmGetResolvedInfoResult>(
                (),
                0x734f744cb7d210a2,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetChildOutputDictionaryDeprecatedResponseFut = fidl::client::QueryResponseFut<
        RealmGetChildOutputDictionaryDeprecatedResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_child_output_dictionary_deprecated(
        &self,
        mut child: &fdomain_fuchsia_component_decl::ChildRef,
    ) -> Self::GetChildOutputDictionaryDeprecatedResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RealmGetChildOutputDictionaryDeprecatedResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<RealmGetChildOutputDictionaryDeprecatedResponse, Error>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x39245b02aba94364,
            >(_buf?)?;
            Ok(_response.map(|x| x.dictionary))
        }
        self.client.send_query_and_decode::<
            RealmGetChildOutputDictionaryDeprecatedRequest,
            RealmGetChildOutputDictionaryDeprecatedResult,
        >(
            (child,),
            0x39245b02aba94364,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetChildOutputDictionaryResponseFut = fidl::client::QueryResponseFut<
        RealmGetChildOutputDictionaryResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_child_output_dictionary(
        &self,
        mut child: &fdomain_fuchsia_component_decl::ChildRef,
    ) -> Self::GetChildOutputDictionaryResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RealmGetChildOutputDictionaryResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<RealmGetChildOutputDictionaryResponse, Error>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x4259d08d261d5610,
            >(_buf?)?;
            Ok(_response.map(|x| x.dictionary))
        }
        self.client.send_query_and_decode::<
            RealmGetChildOutputDictionaryRequest,
            RealmGetChildOutputDictionaryResult,
        >(
            (child,),
            0x4259d08d261d5610,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

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

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

    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 {
        RealmControlHandle { 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 RealmRequestStream {
    type Item = Result<RealmRequest, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled RealmRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, 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 {
                    0x7150b7898d1b1180 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RealmOpenControllerRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<RealmOpenControllerRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RealmControlHandle { inner: this.inner.clone() };
                        Ok(RealmRequest::OpenController {
                            child: req.child,
                            controller: req.controller,

                            responder: RealmOpenControllerResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7f993235ca59f92c => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RealmOpenExposedDirRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<RealmOpenExposedDirRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RealmControlHandle { inner: this.inner.clone() };
                        Ok(RealmRequest::OpenExposedDir {
                            child: req.child,
                            exposed_dir: req.exposed_dir,

                            responder: RealmOpenExposedDirResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x43e48ce8483d7560 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RealmCreateChildRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<RealmCreateChildRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RealmControlHandle { inner: this.inner.clone() };
                        Ok(RealmRequest::CreateChild {
                            collection: req.collection,
                            decl: req.decl,
                            args: req.args,

                            responder: RealmCreateChildResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x71d8caf8850c9222 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RealmDestroyChildRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<RealmDestroyChildRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RealmControlHandle { inner: this.inner.clone() };
                        Ok(RealmRequest::DestroyChild {
                            child: req.child,

                            responder: RealmDestroyChildResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6888a76683efc0a1 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RealmListChildrenRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<RealmListChildrenRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RealmControlHandle { inner: this.inner.clone() };
                        Ok(RealmRequest::ListChildren {
                            collection: req.collection,
                            iter: req.iter,

                            responder: RealmListChildrenResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x734f744cb7d210a2 => {
                        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 = RealmControlHandle { inner: this.inner.clone() };
                        Ok(RealmRequest::GetResolvedInfo {
                            responder: RealmGetResolvedInfoResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x39245b02aba94364 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RealmGetChildOutputDictionaryDeprecatedRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<RealmGetChildOutputDictionaryDeprecatedRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RealmControlHandle { inner: this.inner.clone() };
                        Ok(RealmRequest::GetChildOutputDictionaryDeprecated {
                            child: req.child,

                            responder: RealmGetChildOutputDictionaryDeprecatedResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4259d08d261d5610 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RealmGetChildOutputDictionaryRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<RealmGetChildOutputDictionaryRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RealmControlHandle { inner: this.inner.clone() };
                        Ok(RealmRequest::GetChildOutputDictionary {
                            child: req.child,

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

/// A protocol used by a component instance to manage its own realm, such as for
/// binding to its children.
///
/// Requests to this protocol are processed in the order they are received.
/// Clients that wish to send requests in parallel should open multiple
/// connections.
///
/// The component framework provides this service to components that use
/// `fuchsia.component.Realm`.
#[derive(Debug)]
pub enum RealmRequest {
    /// Operate on a child component. See documentation for [`Controller`].
    ///
    /// Errors:
    /// - `INVALID_ARGUMENTS`: `child` is not a valid child reference.
    /// - `INSTANCE_NOT_FOUND`: `child` does not exist.
    /// - `INSTANCE_DIED`: This realm no longer exists.
    OpenController {
        child: fdomain_fuchsia_component_decl::ChildRef,
        controller: fdomain_client::fidl::ServerEnd<ControllerMarker>,
        responder: RealmOpenControllerResponder,
    },
    /// Opens the exposed directory of a child component. When this function
    /// successfully returns, `exposed_dir` is bound to a directory that
    /// contains the capabilities which the child exposed to its realm via
    /// `ComponentDecl.exposes` (specified via "expose" declarations in the
    /// component's manifest). The child component will not start as a result of
    /// this call.
    ///
    /// `exposed_dir` is open as long as `child` exists.
    ///
    /// Errors:
    /// - `INVALID_ARGUMENTS`: `child` is not a valid child reference.
    /// - `INSTANCE_NOT_FOUND`: `child` does not exist.
    /// - `INSTANCE_CANNOT_RESOLVE`: `child`'s component declaration failed to resolve.
    /// - `INSTANCE_DIED`: This realm no longer exists.
    OpenExposedDir {
        child: fdomain_fuchsia_component_decl::ChildRef,
        exposed_dir: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::DirectoryMarker>,
        responder: RealmOpenExposedDirResponder,
    },
    /// Creates a child component instance dynamically. When this function
    /// returns successfully, the instance exists, but it may not be running.
    ///
    /// The environment of the child instance is determined by the environment
    /// of the collection. `decl` must not set `environment`.
    ///
    /// If `decl.startup == EAGER`, or `collection.durability == SINGLE_RUN`,
    /// [CreateChild] will start the component and return once the component is
    /// started. Otherwise, [CreateChild] will return immediately after creating
    /// the component and will not start or resolve it.
    ///
    /// Errors:
    /// - `INVALID_ARGUMENTS`: `collection` is not a valid reference or `child`
    ///   is not a valid declaration.
    /// - `COLLECTION_NOT_FOUND`: `collection` does not exist.
    /// - `INSTANCE_ALREADY_EXISTS`: `decl.name` already exists in `collection`.
    /// - `INSTANCE_CANNOT_RESOLVE`: `child`'s component declaration failed to resolve
    ///   in a `SingleRun` collection.
    /// - `NO_SPACE`: Could not allocate storage for the new instance.
    /// - `INSTANCE_DIED`: This realm no longer exists.
    CreateChild {
        collection: fdomain_fuchsia_component_decl::CollectionRef,
        decl: fdomain_fuchsia_component_decl::Child,
        args: CreateChildArgs,
        responder: RealmCreateChildResponder,
    },
    /// Destroys a dynamically-created component instance. When this function
    /// returns, the instance is destroyed and has stopped running.  However,
    /// cleanup of the component's resources (such as its isolated storage) may
    /// happen in the background after this function returns.
    ///
    /// Errors:
    /// - `INVALID_ARGUMENTS`: `child` is not a valid reference or does not refer
    ///   to a dynamic instance.
    /// - `INSTANCE_NOT_FOUND`: `child` does not exist.
    /// - `COLLECTION_NOT_FOUND`: `collection` does not exist.
    /// - `INSTANCE_DIED`: This realm no longer exists.
    DestroyChild {
        child: fdomain_fuchsia_component_decl::ChildRef,
        responder: RealmDestroyChildResponder,
    },
    /// Returns an iterator that lists all instances in a collection.
    ///
    /// NOTE: The results are not guaranteed to be consistent. Instances may be
    /// created or destroyed while the iterator is live, but those changes
    /// won't be observed by the iterator after this method returns.
    ///
    /// Errors:
    /// - `INVALID_ARGUMENTS`: `collection` is not a valid reference or `iter`
    /// does not have `ZX_RIGHT_WAIT`.
    /// - `COLLECTION_NOT_FOUND`: `collection` does not exist.
    /// - `INSTANCE_DIED`: This realm no longer exists.
    /// - If `iter` does not have standard channel rights, this function may
    ///   return `ACCESS_DENIED` or component manager may close `iter`.
    ListChildren {
        collection: fdomain_fuchsia_component_decl::CollectionRef,
        iter: fdomain_client::fidl::ServerEnd<ChildIteratorMarker>,
        responder: RealmListChildrenResponder,
    },
    /// Returns the set of information that was given to the component framework
    /// by this component's resolver.
    GetResolvedInfo { responder: RealmGetResolvedInfoResponder },
    GetChildOutputDictionaryDeprecated {
        child: fdomain_fuchsia_component_decl::ChildRef,
        responder: RealmGetChildOutputDictionaryDeprecatedResponder,
    },
    /// Returns a reference to a child's output dictionary, which may be
    /// interacted with by using the fuchsia.component.runtime.Capabilities API.
    GetChildOutputDictionary {
        child: fdomain_fuchsia_component_decl::ChildRef,
        responder: RealmGetChildOutputDictionaryResponder,
    },
}

impl RealmRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_open_controller(
        self,
    ) -> Option<(
        fdomain_fuchsia_component_decl::ChildRef,
        fdomain_client::fidl::ServerEnd<ControllerMarker>,
        RealmOpenControllerResponder,
    )> {
        if let RealmRequest::OpenController { child, controller, responder } = self {
            Some((child, controller, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_open_exposed_dir(
        self,
    ) -> Option<(
        fdomain_fuchsia_component_decl::ChildRef,
        fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::DirectoryMarker>,
        RealmOpenExposedDirResponder,
    )> {
        if let RealmRequest::OpenExposedDir { child, exposed_dir, responder } = self {
            Some((child, exposed_dir, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_create_child(
        self,
    ) -> Option<(
        fdomain_fuchsia_component_decl::CollectionRef,
        fdomain_fuchsia_component_decl::Child,
        CreateChildArgs,
        RealmCreateChildResponder,
    )> {
        if let RealmRequest::CreateChild { collection, decl, args, responder } = self {
            Some((collection, decl, args, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_destroy_child(
        self,
    ) -> Option<(fdomain_fuchsia_component_decl::ChildRef, RealmDestroyChildResponder)> {
        if let RealmRequest::DestroyChild { child, responder } = self {
            Some((child, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_list_children(
        self,
    ) -> Option<(
        fdomain_fuchsia_component_decl::CollectionRef,
        fdomain_client::fidl::ServerEnd<ChildIteratorMarker>,
        RealmListChildrenResponder,
    )> {
        if let RealmRequest::ListChildren { collection, iter, responder } = self {
            Some((collection, iter, responder))
        } else {
            None
        }
    }

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_child_output_dictionary_deprecated(
        self,
    ) -> Option<(
        fdomain_fuchsia_component_decl::ChildRef,
        RealmGetChildOutputDictionaryDeprecatedResponder,
    )> {
        if let RealmRequest::GetChildOutputDictionaryDeprecated { child, responder } = self {
            Some((child, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_child_output_dictionary(
        self,
    ) -> Option<(fdomain_fuchsia_component_decl::ChildRef, RealmGetChildOutputDictionaryResponder)>
    {
        if let RealmRequest::GetChildOutputDictionary { child, responder } = self {
            Some((child, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            RealmRequest::OpenController { .. } => "open_controller",
            RealmRequest::OpenExposedDir { .. } => "open_exposed_dir",
            RealmRequest::CreateChild { .. } => "create_child",
            RealmRequest::DestroyChild { .. } => "destroy_child",
            RealmRequest::ListChildren { .. } => "list_children",
            RealmRequest::GetResolvedInfo { .. } => "get_resolved_info",
            RealmRequest::GetChildOutputDictionaryDeprecated { .. } => {
                "get_child_output_dictionary_deprecated"
            }
            RealmRequest::GetChildOutputDictionary { .. } => "get_child_output_dictionary",
        }
    }
}

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

impl fdomain_client::fidl::ControlHandle for RealmControlHandle {
    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 RealmControlHandle {}

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

/// Set the the channel to be shutdown (see [`RealmControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for RealmOpenControllerResponder {
    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 RealmOpenControllerResponder {
    type ControlHandle = RealmControlHandle;

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

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

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

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

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

/// Set the the channel to be shutdown (see [`RealmControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for RealmOpenExposedDirResponder {
    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 RealmOpenExposedDirResponder {
    type ControlHandle = RealmControlHandle;

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

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

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

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

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

/// Set the the channel to be shutdown (see [`RealmControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for RealmCreateChildResponder {
    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 RealmCreateChildResponder {
    type ControlHandle = RealmControlHandle;

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

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

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

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

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

/// Set the the channel to be shutdown (see [`RealmControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for RealmDestroyChildResponder {
    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 RealmDestroyChildResponder {
    type ControlHandle = RealmControlHandle;

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

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

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

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

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

/// Set the the channel to be shutdown (see [`RealmControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for RealmListChildrenResponder {
    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 RealmListChildrenResponder {
    type ControlHandle = RealmControlHandle;

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

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

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

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

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

/// Set the the channel to be shutdown (see [`RealmControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for RealmGetResolvedInfoResponder {
    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 RealmGetResolvedInfoResponder {
    type ControlHandle = RealmControlHandle;

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

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

impl RealmGetResolvedInfoResponder {
    /// 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_resolution::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_resolution::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_resolution::Component, Error>,
    ) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<RealmGetResolvedInfoResponse, Error>>(
                result.as_mut().map_err(|e| *e).map(|resolved_info| (resolved_info,)),
                self.tx_id,
                0x734f744cb7d210a2,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

/// Set the the channel to be shutdown (see [`RealmControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for RealmGetChildOutputDictionaryDeprecatedResponder {
    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 RealmGetChildOutputDictionaryDeprecatedResponder {
    type ControlHandle = RealmControlHandle;

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

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

impl RealmGetChildOutputDictionaryDeprecatedResponder {
    /// 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_sandbox::DictionaryRef, 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_sandbox::DictionaryRef, 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_sandbox::DictionaryRef, Error>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            RealmGetChildOutputDictionaryDeprecatedResponse,
            Error,
        >>(
            result.as_mut().map_err(|e| *e).map(|dictionary| (dictionary,)),
            self.tx_id,
            0x39245b02aba94364,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`RealmControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for RealmGetChildOutputDictionaryResponder {
    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 RealmGetChildOutputDictionaryResponder {
    type ControlHandle = RealmControlHandle;

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

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

impl RealmGetChildOutputDictionaryResponder {
    /// 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::EventPair, 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_client::EventPair, Error>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<fdomain_client::EventPair, Error>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            RealmGetChildOutputDictionaryResponse,
            Error,
        >>(
            result.map(|dictionary| (dictionary,)),
            self.tx_id,
            0x4259d08d261d5610,
            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.component.StorageAdmin";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for StorageAdminMarker {}
pub type StorageAdminOpenStorageResult = Result<(), Error>;
pub type StorageAdminListStorageInRealmResult = Result<(), Error>;
pub type StorageAdminOpenComponentStorageByIdResult = Result<(), Error>;
pub type StorageAdminDeleteComponentStorageResult = Result<(), 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.component/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 provided
    /// moniker is relative to the component that declares the storage
    /// capability. Creates the backing sub-directory for this storage if it
    /// hasn't yet been created.
    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. The provided moniker is relative to the component
    /// that declares 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. Creates the
    /// backing sub-directory for this storage if it hasn't yet been created.
    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. Preserves the
    /// component's subdirectory itself within the storage backing directory.
    /// The provided moniker is relative to the component that declares the
    /// storage capability.
    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 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, 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, 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, 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, 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.component/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 provided
    /// moniker is relative to the component that declares the storage
    /// capability. Creates the backing sub-directory for this storage if it
    /// hasn't yet been created.
    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. The provided moniker is relative to the component
    /// that declares 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. Creates the
    /// backing sub-directory for this storage if it hasn't yet been created.
    OpenComponentStorageById {
        id: String,
        object: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::NodeMarker>,
        responder: StorageAdminOpenComponentStorageByIdResponder,
    },
    /// Deletes the contents of the storage for this component. Preserves the
    /// component's subdirectory itself within the storage backing directory.
    /// The provided moniker is relative to the component that declares the
    /// storage capability.
    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 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<(), 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<(), Error>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), Error>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, 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<(), 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<(), Error>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), Error>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, 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<(), 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<(), Error>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), Error>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, 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<(), 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<(), Error>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), Error>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, 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.component/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.component/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(),
        )
    }
}

mod internal {
    use super::*;

    impl fidl::encoding::ResourceTypeMarker for ControllerOpenExposedDirRequest {
        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 ControllerOpenExposedDirRequest {
        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<
            ControllerOpenExposedDirRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut ControllerOpenExposedDirRequest
    {
        #[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::<ControllerOpenExposedDirRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                ControllerOpenExposedDirRequest,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (<fidl::encoding::Endpoint<
                    fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::DirectoryMarker>,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.exposed_dir
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<
                    fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::DirectoryMarker>,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            ControllerOpenExposedDirRequest,
            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::<ControllerOpenExposedDirRequest>(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 ControllerOpenExposedDirRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                exposed_dir: 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::Endpoint<
                    fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::DirectoryMarker>,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.exposed_dir,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ControllerStartRequest {
        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 ControllerStartRequest {
        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<ControllerStartRequest, fdomain_client::fidl::FDomainResourceDialect>
        for &mut ControllerStartRequest
    {
        #[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::<ControllerStartRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                ControllerStartRequest,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (
                    <StartChildArgs as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.args,
                    ),
                    <fidl::encoding::Endpoint<
                        fdomain_client::fidl::ServerEnd<ExecutionControllerMarker>,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.execution_controller,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<StartChildArgs, fdomain_client::fidl::FDomainResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<
                    fdomain_client::fidl::ServerEnd<ExecutionControllerMarker>,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<ControllerStartRequest, 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::<ControllerStartRequest>(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 ControllerStartRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                args: fidl::new_empty!(
                    StartChildArgs,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                execution_controller: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fdomain_client::fidl::ServerEnd<ExecutionControllerMarker>,
                    >,
                    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!(
                StartChildArgs,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.args,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<
                    fdomain_client::fidl::ServerEnd<ExecutionControllerMarker>,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.execution_controller,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ControllerGetExposedDictionaryResponse {
        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 ControllerGetExposedDictionaryResponse {
        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<
            ControllerGetExposedDictionaryResponse,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut ControllerGetExposedDictionaryResponse
    {
        #[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::<ControllerGetExposedDictionaryResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ControllerGetExposedDictionaryResponse, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fdomain_fuchsia_component_sandbox::DictionaryRef as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.dictionary),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fdomain_fuchsia_component_sandbox::DictionaryRef,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            ControllerGetExposedDictionaryResponse,
            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::<ControllerGetExposedDictionaryResponse>(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 ControllerGetExposedDictionaryResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                dictionary: fidl::new_empty!(
                    fdomain_fuchsia_component_sandbox::DictionaryRef,
                    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!(
                fdomain_fuchsia_component_sandbox::DictionaryRef,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.dictionary,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ControllerGetOutputDictionaryResponse {
        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 ControllerGetOutputDictionaryResponse {
        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<
            ControllerGetOutputDictionaryResponse,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut ControllerGetOutputDictionaryResponse
    {
        #[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::<ControllerGetOutputDictionaryResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                ControllerGetOutputDictionaryResponse,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (<fidl::encoding::HandleType<
                    fdomain_client::EventPair,
                    { fidl::ObjectType::EVENTPAIR.into_raw() },
                    2147483648,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.dictionary
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fdomain_client::EventPair,
                    { fidl::ObjectType::EVENTPAIR.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            ControllerGetOutputDictionaryResponse,
            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::<ControllerGetOutputDictionaryResponse>(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 ControllerGetOutputDictionaryResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                dictionary: fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            ControllerIsStartedResponse,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut ControllerIsStartedResponse
    {
        #[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::<ControllerIsStartedResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                ControllerIsStartedResponse,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.is_started),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<T0: fidl::encoding::Encode<bool, fdomain_client::fidl::FDomainResourceDialect>>
        fidl::encoding::Encode<
            ControllerIsStartedResponse,
            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::<ControllerIsStartedResponse>(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 ControllerIsStartedResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                is_started: fidl::new_empty!(bool, 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!(
                bool,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.is_started,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for EventStreamGetNextResponse {
        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 EventStreamGetNextResponse {
        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<
            EventStreamGetNextResponse,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut EventStreamGetNextResponse
    {
        #[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::<EventStreamGetNextResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<EventStreamGetNextResponse, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fidl::encoding::UnboundedVector<Event> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.events),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::UnboundedVector<Event>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            EventStreamGetNextResponse,
            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::<EventStreamGetNextResponse>(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 EventStreamGetNextResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                events: fidl::new_empty!(
                    fidl::encoding::UnboundedVector<Event>,
                    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<Event>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.events,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for IntrospectorGetMonikerRequest {
        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 IntrospectorGetMonikerRequest {
        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<
            IntrospectorGetMonikerRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut IntrospectorGetMonikerRequest
    {
        #[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::<IntrospectorGetMonikerRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                IntrospectorGetMonikerRequest,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (<fidl::encoding::HandleType<
                    fdomain_client::Event,
                    { fidl::ObjectType::EVENT.into_raw() },
                    2147483648,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.component_instance,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fdomain_client::Event,
                    { fidl::ObjectType::EVENT.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            IntrospectorGetMonikerRequest,
            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::<IntrospectorGetMonikerRequest>(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 IntrospectorGetMonikerRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                component_instance: fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Event, { fidl::ObjectType::EVENT.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for NamespaceCreate2Request {
        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 NamespaceCreate2Request {
        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<
            NamespaceCreate2Request,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut NamespaceCreate2Request
    {
        #[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::<NamespaceCreate2Request>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<NamespaceCreate2Request, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fidl::encoding::UnboundedVector<NamespaceInputEntry2> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.entries),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::UnboundedVector<NamespaceInputEntry2>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            NamespaceCreate2Request,
            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::<NamespaceCreate2Request>(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 NamespaceCreate2Request
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                entries: fidl::new_empty!(
                    fidl::encoding::UnboundedVector<NamespaceInputEntry2>,
                    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<NamespaceInputEntry2>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.entries,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for NamespaceCreateRequest {
        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 NamespaceCreateRequest {
        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<NamespaceCreateRequest, fdomain_client::fidl::FDomainResourceDialect>
        for &mut NamespaceCreateRequest
    {
        #[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::<NamespaceCreateRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<NamespaceCreateRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fidl::encoding::UnboundedVector<NamespaceInputEntry> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.entries),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::UnboundedVector<NamespaceInputEntry>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<NamespaceCreateRequest, 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::<NamespaceCreateRequest>(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 NamespaceCreateRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                entries: fidl::new_empty!(
                    fidl::encoding::UnboundedVector<NamespaceInputEntry>,
                    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<NamespaceInputEntry>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.entries,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for NamespaceInputEntry {
        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 NamespaceInputEntry {
        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<NamespaceInputEntry, fdomain_client::fidl::FDomainResourceDialect>
        for &mut NamespaceInputEntry
    {
        #[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::<NamespaceInputEntry>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<NamespaceInputEntry, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fidl::encoding::BoundedString<4095> as fidl::encoding::ValueTypeMarker>::borrow(&self.path),
                    <fidl::encoding::Endpoint<fdomain_client::fidl::ClientEnd<fdomain_fuchsia_component_sandbox::DictionaryMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.dictionary),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::BoundedString<4095>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<
                    fdomain_client::fidl::ClientEnd<
                        fdomain_fuchsia_component_sandbox::DictionaryMarker,
                    >,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    > fidl::encoding::Encode<NamespaceInputEntry, 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::<NamespaceInputEntry>(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 NamespaceInputEntry
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                path: fidl::new_empty!(
                    fidl::encoding::BoundedString<4095>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                dictionary: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fdomain_client::fidl::ClientEnd<
                            fdomain_fuchsia_component_sandbox::DictionaryMarker,
                        >,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for NamespaceInputEntry2 {
        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 NamespaceInputEntry2 {
        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<NamespaceInputEntry2, fdomain_client::fidl::FDomainResourceDialect>
        for &mut NamespaceInputEntry2
    {
        #[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::<NamespaceInputEntry2>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<NamespaceInputEntry2, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fidl::encoding::BoundedString<4095> as fidl::encoding::ValueTypeMarker>::borrow(&self.path),
                    <fidl::encoding::HandleType<fdomain_client::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.capability),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::BoundedString<4095>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fdomain_client::EventPair,
                    { fidl::ObjectType::EVENTPAIR.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    > fidl::encoding::Encode<NamespaceInputEntry2, 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::<NamespaceInputEntry2>(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 NamespaceInputEntry2
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                path: fidl::new_empty!(
                    fidl::encoding::BoundedString<4095>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                capability: fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for NamespaceCreate2Response {
        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 NamespaceCreate2Response {
        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<
            NamespaceCreate2Response,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut NamespaceCreate2Response
    {
        #[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::<NamespaceCreate2Response>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<NamespaceCreate2Response, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fidl::encoding::UnboundedVector<NamespaceEntry> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.entries),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::UnboundedVector<NamespaceEntry>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            NamespaceCreate2Response,
            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::<NamespaceCreate2Response>(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 NamespaceCreate2Response
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                entries: fidl::new_empty!(
                    fidl::encoding::UnboundedVector<NamespaceEntry>,
                    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<NamespaceEntry>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.entries,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for NamespaceCreateResponse {
        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 NamespaceCreateResponse {
        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<
            NamespaceCreateResponse,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut NamespaceCreateResponse
    {
        #[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::<NamespaceCreateResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<NamespaceCreateResponse, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fidl::encoding::UnboundedVector<NamespaceEntry> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.entries),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::UnboundedVector<NamespaceEntry>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            NamespaceCreateResponse,
            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::<NamespaceCreateResponse>(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 NamespaceCreateResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                entries: fidl::new_empty!(
                    fidl::encoding::UnboundedVector<NamespaceEntry>,
                    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<NamespaceEntry>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.entries,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            RealmCreateChildRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut RealmCreateChildRequest
    {
        #[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::<RealmCreateChildRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RealmCreateChildRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fdomain_fuchsia_component_decl::CollectionRef as fidl::encoding::ValueTypeMarker>::borrow(&self.collection),
                    <fdomain_fuchsia_component_decl::Child as fidl::encoding::ValueTypeMarker>::borrow(&self.decl),
                    <CreateChildArgs as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.args),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fdomain_fuchsia_component_decl::CollectionRef,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fdomain_fuchsia_component_decl::Child,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T2: fidl::encoding::Encode<CreateChildArgs, fdomain_client::fidl::FDomainResourceDialect>,
    >
        fidl::encoding::Encode<
            RealmCreateChildRequest,
            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::<RealmCreateChildRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            self.2.encode(encoder, offset + 32, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for RealmCreateChildRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                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!(
                    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!(
                fdomain_fuchsia_component_decl::CollectionRef,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.collection,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fdomain_fuchsia_component_decl::Child,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.decl,
                decoder,
                offset + 16,
                _depth
            )?;
            fidl::decode!(
                CreateChildArgs,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.args,
                decoder,
                offset + 32,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            RealmGetChildOutputDictionaryDeprecatedRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut RealmGetChildOutputDictionaryDeprecatedRequest
    {
        #[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::<RealmGetChildOutputDictionaryDeprecatedRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RealmGetChildOutputDictionaryDeprecatedRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fdomain_fuchsia_component_decl::ChildRef as fidl::encoding::ValueTypeMarker>::borrow(&self.child),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fdomain_fuchsia_component_decl::ChildRef,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            RealmGetChildOutputDictionaryDeprecatedRequest,
            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::<RealmGetChildOutputDictionaryDeprecatedRequest>(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 RealmGetChildOutputDictionaryDeprecatedRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                child: fidl::new_empty!(
                    fdomain_fuchsia_component_decl::ChildRef,
                    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!(
                fdomain_fuchsia_component_decl::ChildRef,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.child,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            RealmGetChildOutputDictionaryRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut RealmGetChildOutputDictionaryRequest
    {
        #[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::<RealmGetChildOutputDictionaryRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RealmGetChildOutputDictionaryRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fdomain_fuchsia_component_decl::ChildRef as fidl::encoding::ValueTypeMarker>::borrow(&self.child),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fdomain_fuchsia_component_decl::ChildRef,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            RealmGetChildOutputDictionaryRequest,
            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::<RealmGetChildOutputDictionaryRequest>(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 RealmGetChildOutputDictionaryRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                child: fidl::new_empty!(
                    fdomain_fuchsia_component_decl::ChildRef,
                    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!(
                fdomain_fuchsia_component_decl::ChildRef,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.child,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for RealmListChildrenRequest {
        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 RealmListChildrenRequest {
        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<
            RealmListChildrenRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut RealmListChildrenRequest
    {
        #[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::<RealmListChildrenRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RealmListChildrenRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fdomain_fuchsia_component_decl::CollectionRef as fidl::encoding::ValueTypeMarker>::borrow(&self.collection),
                    <fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<ChildIteratorMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.iter),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fdomain_fuchsia_component_decl::CollectionRef,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<ChildIteratorMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            RealmListChildrenRequest,
            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::<RealmListChildrenRequest>(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 RealmListChildrenRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                collection: fidl::new_empty!(
                    fdomain_fuchsia_component_decl::CollectionRef,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                iter: fidl::new_empty!(
                    fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<ChildIteratorMarker>>,
                    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!(
                fdomain_fuchsia_component_decl::CollectionRef,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.collection,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<ChildIteratorMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.iter,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for RealmOpenControllerRequest {
        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 RealmOpenControllerRequest {
        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<
            RealmOpenControllerRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut RealmOpenControllerRequest
    {
        #[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::<RealmOpenControllerRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RealmOpenControllerRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fdomain_fuchsia_component_decl::ChildRef as fidl::encoding::ValueTypeMarker>::borrow(&self.child),
                    <fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<ControllerMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.controller),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fdomain_fuchsia_component_decl::ChildRef,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<ControllerMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            RealmOpenControllerRequest,
            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::<RealmOpenControllerRequest>(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 + 32, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for RealmOpenControllerRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                child: fidl::new_empty!(
                    fdomain_fuchsia_component_decl::ChildRef,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                controller: fidl::new_empty!(
                    fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<ControllerMarker>>,
                    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!(
                fdomain_fuchsia_component_decl::ChildRef,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.child,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<ControllerMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.controller,
                decoder,
                offset + 32,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for RealmOpenExposedDirRequest {
        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 RealmOpenExposedDirRequest {
        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<
            RealmOpenExposedDirRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut RealmOpenExposedDirRequest
    {
        #[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::<RealmOpenExposedDirRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RealmOpenExposedDirRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fdomain_fuchsia_component_decl::ChildRef as fidl::encoding::ValueTypeMarker>::borrow(&self.child),
                    <fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::DirectoryMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.exposed_dir),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fdomain_fuchsia_component_decl::ChildRef,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<
                    fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::DirectoryMarker>,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            RealmOpenExposedDirRequest,
            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::<RealmOpenExposedDirRequest>(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 + 32, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for RealmOpenExposedDirRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                child: fidl::new_empty!(
                    fdomain_fuchsia_component_decl::ChildRef,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                exposed_dir: 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.
            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!(
                fdomain_fuchsia_component_decl::ChildRef,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.child,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<
                    fdomain_client::fidl::ServerEnd<fdomain_fuchsia_io::DirectoryMarker>,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.exposed_dir,
                decoder,
                offset + 32,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for RealmGetChildOutputDictionaryDeprecatedResponse {
        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 RealmGetChildOutputDictionaryDeprecatedResponse {
        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<
            RealmGetChildOutputDictionaryDeprecatedResponse,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut RealmGetChildOutputDictionaryDeprecatedResponse
    {
        #[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::<RealmGetChildOutputDictionaryDeprecatedResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RealmGetChildOutputDictionaryDeprecatedResponse, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fdomain_fuchsia_component_sandbox::DictionaryRef as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.dictionary),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fdomain_fuchsia_component_sandbox::DictionaryRef,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            RealmGetChildOutputDictionaryDeprecatedResponse,
            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::<RealmGetChildOutputDictionaryDeprecatedResponse>(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 RealmGetChildOutputDictionaryDeprecatedResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                dictionary: fidl::new_empty!(
                    fdomain_fuchsia_component_sandbox::DictionaryRef,
                    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!(
                fdomain_fuchsia_component_sandbox::DictionaryRef,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.dictionary,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for RealmGetChildOutputDictionaryResponse {
        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 RealmGetChildOutputDictionaryResponse {
        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<
            RealmGetChildOutputDictionaryResponse,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut RealmGetChildOutputDictionaryResponse
    {
        #[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::<RealmGetChildOutputDictionaryResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                RealmGetChildOutputDictionaryResponse,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (<fidl::encoding::HandleType<
                    fdomain_client::EventPair,
                    { fidl::ObjectType::EVENTPAIR.into_raw() },
                    2147483648,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.dictionary
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fdomain_client::EventPair,
                    { fidl::ObjectType::EVENTPAIR.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            RealmGetChildOutputDictionaryResponse,
            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::<RealmGetChildOutputDictionaryResponse>(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 RealmGetChildOutputDictionaryResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                dictionary: fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for RealmGetResolvedInfoResponse {
        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 RealmGetResolvedInfoResponse {
        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<
            RealmGetResolvedInfoResponse,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut RealmGetResolvedInfoResponse
    {
        #[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::<RealmGetResolvedInfoResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RealmGetResolvedInfoResponse, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fdomain_fuchsia_component_resolution::Component as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.resolved_info),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fdomain_fuchsia_component_resolution::Component,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            RealmGetResolvedInfoResponse,
            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::<RealmGetResolvedInfoResponse>(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 RealmGetResolvedInfoResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                resolved_info: fidl::new_empty!(
                    fdomain_fuchsia_component_resolution::Component,
                    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!(
                fdomain_fuchsia_component_resolution::Component,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.resolved_info,
                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(())
        }
    }

    impl CapabilityRequestedPayload {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.capability {
                return 2;
            }
            if let Some(_) = self.name {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for CapabilityRequestedPayload {
        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 CapabilityRequestedPayload {
        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<
            CapabilityRequestedPayload,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut CapabilityRequestedPayload
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CapabilityRequestedPayload>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                fidl::encoding::BoundedString<255>,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.name.as_ref().map(
                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 2 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (2 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                fidl::encoding::HandleType<
                    fdomain_client::Channel,
                    { fidl::ObjectType::CHANNEL.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.capability.as_mut().map(
                    <fidl::encoding::HandleType<
                        fdomain_client::Channel,
                        { fidl::ObjectType::CHANNEL.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
                        decoder.context,
                    );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.name.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::BoundedString<255>,
                        fdomain_client::fidl::FDomainResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::BoundedString<255>,
                    fdomain_client::fidl::FDomainResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 2 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::HandleType<
                    fdomain_client::Channel,
                    { fidl::ObjectType::CHANNEL.into_raw() },
                    2147483648,
                > as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context
                );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref =
                self.capability.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect));
                fidl::decode!(fidl::encoding::HandleType<fdomain_client::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl CreateChildArgs {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.additional_inputs {
                return 5;
            }
            if let Some(_) = self.dictionary {
                return 4;
            }
            if let Some(_) = self.controller {
                return 3;
            }
            if let Some(_) = self.dynamic_offers {
                return 2;
            }
            if let Some(_) = self.numbered_handles {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for CreateChildArgs {
        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 CreateChildArgs {
        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<CreateChildArgs, fdomain_client::fidl::FDomainResourceDialect>
        for &mut CreateChildArgs
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CreateChildArgs>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fdomain_fuchsia_process::HandleInfo, 128>, fdomain_client::fidl::FDomainResourceDialect>(
            self.numbered_handles.as_mut().map(<fidl::encoding::Vector<fdomain_fuchsia_process::HandleInfo, 128> as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
            encoder, offset + cur_offset, depth
        )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 2 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (2 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fdomain_fuchsia_component_decl::Offer, 128>, fdomain_client::fidl::FDomainResourceDialect>(
            self.dynamic_offers.as_ref().map(<fidl::encoding::Vector<fdomain_fuchsia_component_decl::Offer, 128> as fidl::encoding::ValueTypeMarker>::borrow),
            encoder, offset + cur_offset, depth
        )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 3 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (3 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<ControllerMarker>>, fdomain_client::fidl::FDomainResourceDialect>(
            self.controller.as_mut().map(<fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<ControllerMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
            encoder, offset + cur_offset, depth
        )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 4 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (4 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fdomain_fuchsia_component_sandbox::DictionaryRef, fdomain_client::fidl::FDomainResourceDialect>(
            self.dictionary.as_mut().map(<fdomain_fuchsia_component_sandbox::DictionaryRef as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
            encoder, offset + cur_offset, depth
        )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 5 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (5 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                fidl::encoding::HandleType<
                    fdomain_client::EventPair,
                    { fidl::ObjectType::EVENTPAIR.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.additional_inputs.as_mut().map(
                    <fidl::encoding::HandleType<
                        fdomain_client::EventPair,
                        { fidl::ObjectType::EVENTPAIR.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::Vector<
                    fdomain_fuchsia_process::HandleInfo,
                    128,
                > as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context
                );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref =
                self.numbered_handles.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fdomain_fuchsia_process::HandleInfo, 128>, fdomain_client::fidl::FDomainResourceDialect));
                fidl::decode!(fidl::encoding::Vector<fdomain_fuchsia_process::HandleInfo, 128>, fdomain_client::fidl::FDomainResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 2 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::Vector<
                    fdomain_fuchsia_component_decl::Offer,
                    128,
                > as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context
                );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref =
                self.dynamic_offers.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fdomain_fuchsia_component_decl::Offer, 128>, fdomain_client::fidl::FDomainResourceDialect));
                fidl::decode!(fidl::encoding::Vector<fdomain_fuchsia_component_decl::Offer, 128>, fdomain_client::fidl::FDomainResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 3 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::Endpoint<
                    fdomain_client::fidl::ServerEnd<ControllerMarker>,
                > as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context
                );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.controller.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<ControllerMarker>>,
                        fdomain_client::fidl::FDomainResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<ControllerMarker>>,
                    fdomain_client::fidl::FDomainResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 4 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fdomain_fuchsia_component_sandbox::DictionaryRef as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.dictionary.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fdomain_fuchsia_component_sandbox::DictionaryRef,
                        fdomain_client::fidl::FDomainResourceDialect
                    )
                });
                fidl::decode!(
                    fdomain_fuchsia_component_sandbox::DictionaryRef,
                    fdomain_client::fidl::FDomainResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 5 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::HandleType<
                    fdomain_client::EventPair,
                    { fidl::ObjectType::EVENTPAIR.into_raw() },
                    2147483648,
                > as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context
                );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref =
                self.additional_inputs.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect));
                fidl::decode!(fidl::encoding::HandleType<fdomain_client::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl DebugStartedPayload {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.break_on_start {
                return 2;
            }
            if let Some(_) = self.runtime_dir {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for DebugStartedPayload {
        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 DebugStartedPayload {
        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<DebugStartedPayload, fdomain_client::fidl::FDomainResourceDialect>
        for &mut DebugStartedPayload
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DebugStartedPayload>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                fidl::encoding::Endpoint<
                    fdomain_client::fidl::ClientEnd<fdomain_fuchsia_io::DirectoryMarker>,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.runtime_dir.as_mut().map(
                    <fidl::encoding::Endpoint<
                        fdomain_client::fidl::ClientEnd<fdomain_fuchsia_io::DirectoryMarker>,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 2 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (2 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                fidl::encoding::HandleType<
                    fdomain_client::EventPair,
                    { fidl::ObjectType::EVENTPAIR.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.break_on_start.as_mut().map(
                    <fidl::encoding::HandleType<
                        fdomain_client::EventPair,
                        { fidl::ObjectType::EVENTPAIR.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::Endpoint<
                    fdomain_client::fidl::ClientEnd<fdomain_fuchsia_io::DirectoryMarker>,
                > as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context
                );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.runtime_dir.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::Endpoint<
                            fdomain_client::fidl::ClientEnd<fdomain_fuchsia_io::DirectoryMarker>,
                        >,
                        fdomain_client::fidl::FDomainResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::Endpoint<
                        fdomain_client::fidl::ClientEnd<fdomain_fuchsia_io::DirectoryMarker>,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 2 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::HandleType<
                    fdomain_client::EventPair,
                    { fidl::ObjectType::EVENTPAIR.into_raw() },
                    2147483648,
                > as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context
                );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref =
                self.break_on_start.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect));
                fidl::decode!(fidl::encoding::HandleType<fdomain_client::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl Event {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.payload {
                return 2;
            }
            if let Some(_) = self.header {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for Event {
        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 Event {
        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<Event, fdomain_client::fidl::FDomainResourceDialect>
        for &mut Event
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Event>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                EventHeader,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.header.as_ref().map(<EventHeader as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 2 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (2 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                EventPayload,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.payload
                    .as_mut()
                    .map(<EventPayload as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <EventHeader as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.header.get_or_insert_with(|| {
                    fidl::new_empty!(EventHeader, fdomain_client::fidl::FDomainResourceDialect)
                });
                fidl::decode!(
                    EventHeader,
                    fdomain_client::fidl::FDomainResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 2 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <EventPayload as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.payload.get_or_insert_with(|| {
                    fidl::new_empty!(EventPayload, fdomain_client::fidl::FDomainResourceDialect)
                });
                fidl::decode!(
                    EventPayload,
                    fdomain_client::fidl::FDomainResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl NamespaceEntry {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.directory {
                return 2;
            }
            if let Some(_) = self.path {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for NamespaceEntry {
        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 NamespaceEntry {
        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<NamespaceEntry, fdomain_client::fidl::FDomainResourceDialect>
        for &mut NamespaceEntry
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NamespaceEntry>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4095>, fdomain_client::fidl::FDomainResourceDialect>(
            self.path.as_ref().map(<fidl::encoding::BoundedString<4095> as fidl::encoding::ValueTypeMarker>::borrow),
            encoder, offset + cur_offset, depth
        )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 2 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (2 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                fidl::encoding::Endpoint<
                    fdomain_client::fidl::ClientEnd<fdomain_fuchsia_io::DirectoryMarker>,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.directory.as_mut().map(
                    <fidl::encoding::Endpoint<
                        fdomain_client::fidl::ClientEnd<fdomain_fuchsia_io::DirectoryMarker>,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::BoundedString<4095> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.path.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::BoundedString<4095>,
                        fdomain_client::fidl::FDomainResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::BoundedString<4095>,
                    fdomain_client::fidl::FDomainResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 2 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::Endpoint<
                    fdomain_client::fidl::ClientEnd<fdomain_fuchsia_io::DirectoryMarker>,
                > as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context
                );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.directory.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::Endpoint<
                            fdomain_client::fidl::ClientEnd<fdomain_fuchsia_io::DirectoryMarker>,
                        >,
                        fdomain_client::fidl::FDomainResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::Endpoint<
                        fdomain_client::fidl::ClientEnd<fdomain_fuchsia_io::DirectoryMarker>,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl StartChildArgs {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.additional_inputs {
                return 4;
            }
            if let Some(_) = self.dictionary {
                return 3;
            }
            if let Some(_) = self.namespace_entries {
                return 2;
            }
            if let Some(_) = self.numbered_handles {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for StartChildArgs {
        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 StartChildArgs {
        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<StartChildArgs, fdomain_client::fidl::FDomainResourceDialect>
        for &mut StartChildArgs
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<StartChildArgs>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fdomain_fuchsia_process::HandleInfo, 128>, fdomain_client::fidl::FDomainResourceDialect>(
            self.numbered_handles.as_mut().map(<fidl::encoding::Vector<fdomain_fuchsia_process::HandleInfo, 128> as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
            encoder, offset + cur_offset, depth
        )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 2 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (2 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<NamespaceEntry, 32>, fdomain_client::fidl::FDomainResourceDialect>(
            self.namespace_entries.as_mut().map(<fidl::encoding::Vector<NamespaceEntry, 32> as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
            encoder, offset + cur_offset, depth
        )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 3 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (3 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fdomain_fuchsia_component_sandbox::DictionaryRef, fdomain_client::fidl::FDomainResourceDialect>(
            self.dictionary.as_mut().map(<fdomain_fuchsia_component_sandbox::DictionaryRef as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
            encoder, offset + cur_offset, depth
        )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 4 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (4 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                fidl::encoding::HandleType<
                    fdomain_client::EventPair,
                    { fidl::ObjectType::EVENTPAIR.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.additional_inputs.as_mut().map(
                    <fidl::encoding::HandleType<
                        fdomain_client::EventPair,
                        { fidl::ObjectType::EVENTPAIR.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::Vector<
                    fdomain_fuchsia_process::HandleInfo,
                    128,
                > as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context
                );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref =
                self.numbered_handles.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fdomain_fuchsia_process::HandleInfo, 128>, fdomain_client::fidl::FDomainResourceDialect));
                fidl::decode!(fidl::encoding::Vector<fdomain_fuchsia_process::HandleInfo, 128>, fdomain_client::fidl::FDomainResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 2 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::Vector<NamespaceEntry, 32> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref =
                self.namespace_entries.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<NamespaceEntry, 32>, fdomain_client::fidl::FDomainResourceDialect));
                fidl::decode!(fidl::encoding::Vector<NamespaceEntry, 32>, fdomain_client::fidl::FDomainResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 3 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fdomain_fuchsia_component_sandbox::DictionaryRef as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.dictionary.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fdomain_fuchsia_component_sandbox::DictionaryRef,
                        fdomain_client::fidl::FDomainResourceDialect
                    )
                });
                fidl::decode!(
                    fdomain_fuchsia_component_sandbox::DictionaryRef,
                    fdomain_client::fidl::FDomainResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 4 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::HandleType<
                    fdomain_client::EventPair,
                    { fidl::ObjectType::EVENTPAIR.into_raw() },
                    2147483648,
                > as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context
                );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref =
                self.additional_inputs.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect));
                fidl::decode!(fidl::encoding::HandleType<fdomain_client::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for EventPayload {
        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 EventPayload {
        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<EventPayload, fdomain_client::fidl::FDomainResourceDialect>
        for &mut EventPayload
    {
        #[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::<EventPayload>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
            EventPayload::CapabilityRequested(ref mut val) => {
                fidl::encoding::encode_in_envelope::<CapabilityRequestedPayload, fdomain_client::fidl::FDomainResourceDialect>(
                    <CapabilityRequestedPayload as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            EventPayload::Purged(ref val) => {
                fidl::encoding::encode_in_envelope::<PurgedPayload, fdomain_client::fidl::FDomainResourceDialect>(
                    <PurgedPayload as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            EventPayload::Discovered(ref val) => {
                fidl::encoding::encode_in_envelope::<DiscoveredPayload, fdomain_client::fidl::FDomainResourceDialect>(
                    <DiscoveredPayload as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            EventPayload::Destroyed(ref val) => {
                fidl::encoding::encode_in_envelope::<DestroyedPayload, fdomain_client::fidl::FDomainResourceDialect>(
                    <DestroyedPayload as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            EventPayload::Resolved(ref val) => {
                fidl::encoding::encode_in_envelope::<ResolvedPayload, fdomain_client::fidl::FDomainResourceDialect>(
                    <ResolvedPayload as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            EventPayload::Started(ref val) => {
                fidl::encoding::encode_in_envelope::<StartedPayload, fdomain_client::fidl::FDomainResourceDialect>(
                    <StartedPayload as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            EventPayload::Stopped(ref val) => {
                fidl::encoding::encode_in_envelope::<StoppedPayload, fdomain_client::fidl::FDomainResourceDialect>(
                    <StoppedPayload as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            EventPayload::DebugStarted(ref mut val) => {
                fidl::encoding::encode_in_envelope::<DebugStartedPayload, fdomain_client::fidl::FDomainResourceDialect>(
                    <DebugStartedPayload as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            EventPayload::Unresolved(ref val) => {
                fidl::encoding::encode_in_envelope::<UnresolvedPayload, fdomain_client::fidl::FDomainResourceDialect>(
                    <UnresolvedPayload as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            EventPayload::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
        }
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect> for EventPayload {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::__SourceBreaking { unknown_ordinal: 0 }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            #[allow(unused_variables)]
            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            let (ordinal, inlined, num_bytes, num_handles) =
                fidl::encoding::decode_union_inline_portion(decoder, offset)?;

            let member_inline_size = match ordinal {
                1 => <CapabilityRequestedPayload as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context,
                ),
                2 => <PurgedPayload as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                4 => {
                    <DiscoveredPayload as fidl::encoding::TypeMarker>::inline_size(decoder.context)
                }
                5 => <DestroyedPayload as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                6 => <ResolvedPayload as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                7 => <StartedPayload as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                8 => <StoppedPayload as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                9 => <DebugStartedPayload as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context,
                ),
                10 => {
                    <UnresolvedPayload as fidl::encoding::TypeMarker>::inline_size(decoder.context)
                }
                0 => return Err(fidl::Error::UnknownUnionTag),
                _ => num_bytes as usize,
            };

            if inlined != (member_inline_size <= 4) {
                return Err(fidl::Error::InvalidInlineBitInEnvelope);
            }
            let _inner_offset;
            if inlined {
                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
                _inner_offset = offset + 8;
            } else {
                depth.increment()?;
                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
            }
            match ordinal {
                1 => {
                    #[allow(irrefutable_let_patterns)]
                    if let EventPayload::CapabilityRequested(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = EventPayload::CapabilityRequested(fidl::new_empty!(
                            CapabilityRequestedPayload,
                            fdomain_client::fidl::FDomainResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let EventPayload::CapabilityRequested(ref mut val) = self {
                        fidl::decode!(
                            CapabilityRequestedPayload,
                            fdomain_client::fidl::FDomainResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                2 => {
                    #[allow(irrefutable_let_patterns)]
                    if let EventPayload::Purged(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = EventPayload::Purged(fidl::new_empty!(
                            PurgedPayload,
                            fdomain_client::fidl::FDomainResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let EventPayload::Purged(ref mut val) = self {
                        fidl::decode!(
                            PurgedPayload,
                            fdomain_client::fidl::FDomainResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                4 => {
                    #[allow(irrefutable_let_patterns)]
                    if let EventPayload::Discovered(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = EventPayload::Discovered(fidl::new_empty!(
                            DiscoveredPayload,
                            fdomain_client::fidl::FDomainResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let EventPayload::Discovered(ref mut val) = self {
                        fidl::decode!(
                            DiscoveredPayload,
                            fdomain_client::fidl::FDomainResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                5 => {
                    #[allow(irrefutable_let_patterns)]
                    if let EventPayload::Destroyed(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = EventPayload::Destroyed(fidl::new_empty!(
                            DestroyedPayload,
                            fdomain_client::fidl::FDomainResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let EventPayload::Destroyed(ref mut val) = self {
                        fidl::decode!(
                            DestroyedPayload,
                            fdomain_client::fidl::FDomainResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                6 => {
                    #[allow(irrefutable_let_patterns)]
                    if let EventPayload::Resolved(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = EventPayload::Resolved(fidl::new_empty!(
                            ResolvedPayload,
                            fdomain_client::fidl::FDomainResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let EventPayload::Resolved(ref mut val) = self {
                        fidl::decode!(
                            ResolvedPayload,
                            fdomain_client::fidl::FDomainResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                7 => {
                    #[allow(irrefutable_let_patterns)]
                    if let EventPayload::Started(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = EventPayload::Started(fidl::new_empty!(
                            StartedPayload,
                            fdomain_client::fidl::FDomainResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let EventPayload::Started(ref mut val) = self {
                        fidl::decode!(
                            StartedPayload,
                            fdomain_client::fidl::FDomainResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                8 => {
                    #[allow(irrefutable_let_patterns)]
                    if let EventPayload::Stopped(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = EventPayload::Stopped(fidl::new_empty!(
                            StoppedPayload,
                            fdomain_client::fidl::FDomainResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let EventPayload::Stopped(ref mut val) = self {
                        fidl::decode!(
                            StoppedPayload,
                            fdomain_client::fidl::FDomainResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                9 => {
                    #[allow(irrefutable_let_patterns)]
                    if let EventPayload::DebugStarted(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = EventPayload::DebugStarted(fidl::new_empty!(
                            DebugStartedPayload,
                            fdomain_client::fidl::FDomainResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let EventPayload::DebugStarted(ref mut val) = self {
                        fidl::decode!(
                            DebugStartedPayload,
                            fdomain_client::fidl::FDomainResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                10 => {
                    #[allow(irrefutable_let_patterns)]
                    if let EventPayload::Unresolved(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = EventPayload::Unresolved(fidl::new_empty!(
                            UnresolvedPayload,
                            fdomain_client::fidl::FDomainResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let EventPayload::Unresolved(ref mut val) = self {
                        fidl::decode!(
                            UnresolvedPayload,
                            fdomain_client::fidl::FDomainResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                #[allow(deprecated)]
                ordinal => {
                    for _ in 0..num_handles {
                        decoder.drop_next_handle()?;
                    }
                    *self = EventPayload::__SourceBreaking { unknown_ordinal: ordinal };
                }
            }
            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
                return Err(fidl::Error::InvalidNumBytesInEnvelope);
            }
            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
            }
            Ok(())
        }
    }
}