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

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

use bitflags::bitflags;
use fidl::client::QueryResponseFut;
use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
use fidl::endpoints::{ControlHandle as _, Responder as _};
use futures::future::{self, MaybeDone, TryFutureExt};
use zx_status;

pub type ChildName = String;

pub type Name = String;

pub type UrlScheme = String;

/// The maximum string length of a capability ID.
/// This value is currently set arbitrarily.
pub const MAX_CAPABILITY_ID_LENGTH: u64 = 50;

/// The maximum number of children that the a call `ChildIterator.Next`
/// can return.
/// Note, this is not a limit on the number of children that can be added
/// to a component. This is merely a limit for a single invocation of the
/// `Next` method.
pub const MAX_CHILD_COUNT: u32 = 128;

pub const MAX_CHILD_NAME_LENGTH: u32 = 1024;

/// The maximum number of dynamic offers that can target a created component.
pub const MAX_DYNAMIC_OFFER_COUNT: u32 = 128;

/// The maximum string length of an error description.
pub const MAX_ERROR_DESCRIPTION_LENGTH: u64 = 100;

/// The maximum number of handles that can be passed to a created component.
pub const MAX_HANDLE_COUNT: u32 = 128;

pub const MAX_MONIKER_LENGTH: u32 = 4096;

pub const MAX_NAMESPACE_COUNT: u32 = 32;

pub const MAX_NAME_LENGTH: u64 = fidl_fuchsia_io::MAX_NAME_LENGTH as u64;

/// The maximum number of events that a receiver can listen to.
pub const MAX_NUM_EVENTS_RECEIVED: u64 = 100;

pub const MAX_PATH_LENGTH: u64 = fidl_fuchsia_io::MAX_PATH_LENGTH as u64;

/// The maximum number of requests per event subscription.
pub const MAX_SUBSCRIPTION_REQUESTS: u32 = 2;

pub const MAX_URL_SCHEME_LENGTH: u64 = MAX_NAME_LENGTH as u64;

/// Standard error codes for component framework protocols.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum Error {
    /// Component manager encountered an otherwise unspecified error while
    /// performing the operation.
    Internal,
    /// At least one argument had an invalid format.
    InvalidArguments,
    /// The feature is not yet supported.
    Unsupported,
    /// The caller did not have permission to perform the specified operation,
    /// or one of the handles provided to the call had insufficient rights.
    AccessDenied,
    /// The component instance was not found.
    InstanceNotFound,
    /// The component instance already exists.
    InstanceAlreadyExists,
    /// The component instance could not be started.
    InstanceCannotStart,
    /// Failed to resolve the component's declaration.
    InstanceCannotResolve,
    /// The component collection was not found.
    CollectionNotFound,
    /// There were insufficient resources to perform the operation.
    ResourceUnavailable,
    /// The component instance died unexpectedly.
    InstanceDied,
    /// The requested resource does not exist.
    ResourceNotFound,
    /// Failed to unresolve the component.
    InstanceCannotUnresolve,
    /// The component instance has already been started.
    InstanceAlreadyStarted,
    #[doc(hidden)]
    __SourceBreaking { unknown_ordinal: u32 },
}

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

impl Error {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            1 => Some(Self::Internal),
            2 => Some(Self::InvalidArguments),
            3 => Some(Self::Unsupported),
            4 => Some(Self::AccessDenied),
            5 => Some(Self::InstanceNotFound),
            6 => Some(Self::InstanceAlreadyExists),
            7 => Some(Self::InstanceCannotStart),
            8 => Some(Self::InstanceCannotResolve),
            9 => Some(Self::CollectionNotFound),
            10 => Some(Self::ResourceUnavailable),
            11 => Some(Self::InstanceDied),
            12 => Some(Self::ResourceNotFound),
            13 => Some(Self::InstanceCannotUnresolve),
            14 => Some(Self::InstanceAlreadyStarted),
            _ => None,
        }
    }

    #[inline]
    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
        match prim {
            1 => Self::Internal,
            2 => Self::InvalidArguments,
            3 => Self::Unsupported,
            4 => Self::AccessDenied,
            5 => Self::InstanceNotFound,
            6 => Self::InstanceAlreadyExists,
            7 => Self::InstanceCannotStart,
            8 => Self::InstanceCannotResolve,
            9 => Self::CollectionNotFound,
            10 => Self::ResourceUnavailable,
            11 => Self::InstanceDied,
            12 => Self::ResourceNotFound,
            13 => Self::InstanceCannotUnresolve,
            14 => Self::InstanceAlreadyStarted,
            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
        }
    }

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

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        match self {
            Self::Internal => 1,
            Self::InvalidArguments => 2,
            Self::Unsupported => 3,
            Self::AccessDenied => 4,
            Self::InstanceNotFound => 5,
            Self::InstanceAlreadyExists => 6,
            Self::InstanceCannotStart => 7,
            Self::InstanceCannotResolve => 8,
            Self::CollectionNotFound => 9,
            Self::ResourceUnavailable => 10,
            Self::InstanceDied => 11,
            Self::ResourceNotFound => 12,
            Self::InstanceCannotUnresolve => 13,
            Self::InstanceAlreadyStarted => 14,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

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

/// These EventTypes are used for the EventStream protocol.
/// They are FIDL versions of the EventType enum in hooks.rs and have
/// the same meaning.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum EventType {
    /// A capability provided by this component has been requested. The event
    /// payload carries the request channel.
    CapabilityRequested = 1,
    /// A directory exposed to the framework by a component is available.
    DirectoryReady = 2,
    /// A component instance was discovered. This is the first stage in the lifecycle
    /// of components. Dispatched for dynamic children when they're created, for static
    /// children when their parent is resolved, and for the root when the component manager
    /// starts.
    Discovered = 3,
    /// The instance is destroyed and no longer exists.
    Destroyed = 4,
    /// An instance's declaration was resolved successfully for the first time.
    Resolved = 5,
    /// This instance has started, according to component manager. However, if this is an
    /// executable component, the runner has further work to do to launch the component.
    Started = 6,
    /// An instance was stopped successfully.
    Stopped = 7,
    /// Similar to STARTED, except the payload will carry an eventpair that the subscriber
    /// could use to defer the launch of the component. This allows, e.g., a debugger to
    /// perform some setup before any processes are created.
    DebugStarted = 8,
    /// An instance was unresolved successfully.
    Unresolved = 9,
}

impl EventType {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            1 => Some(Self::CapabilityRequested),
            2 => Some(Self::DirectoryReady),
            3 => Some(Self::Discovered),
            4 => Some(Self::Destroyed),
            5 => Some(Self::Resolved),
            6 => Some(Self::Started),
            7 => Some(Self::Stopped),
            8 => Some(Self::DebugStarted),
            9 => Some(Self::Unresolved),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        self as u32
    }

    #[deprecated = "Strict enums should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

/// Error returned from methods in [`Namespace`].
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum NamespaceError {
    /// The parent of a parent shares a prefix with another namespace entry
    Shadow,
    /// Two entries have the same namespace path.
    Duplicate,
    /// Failed to convert a namespace dictionary to a directory.
    Conversion,
    /// A namespace entry was invalid.
    BadEntry,
    /// There was an error reading from one of the dictionaries.
    DictionaryRead,
    #[doc(hidden)]
    __SourceBreaking { unknown_ordinal: u32 },
}

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

impl NamespaceError {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            1 => Some(Self::Shadow),
            2 => Some(Self::Duplicate),
            3 => Some(Self::Conversion),
            4 => Some(Self::BadEntry),
            5 => Some(Self::DictionaryRead),
            _ => None,
        }
    }

    #[inline]
    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
        match prim {
            1 => Self::Shadow,
            2 => Self::Duplicate,
            3 => Self::Conversion,
            4 => Self::BadEntry,
            5 => Self::DictionaryRead,
            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
        }
    }

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

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        match self {
            Self::Shadow => 1,
            Self::Duplicate => 2,
            Self::Conversion => 3,
            Self::BadEntry => 4,
            Self::DictionaryRead => 5,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

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

#[derive(Clone, Debug, PartialEq)]
pub struct ChildIteratorNextResponse {
    pub children: Vec<fidl_fuchsia_component_decl::ChildRef>,
}

impl fidl::Persistable for ChildIteratorNextResponse {}

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

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

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

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

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

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

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

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

#[derive(Clone, Debug, PartialEq)]
pub struct ExecutionControllerOnStopRequest {
    pub stopped_payload: StoppedPayload,
}

impl fidl::Persistable for ExecutionControllerOnStopRequest {}

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

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

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct IntrospectorGetMonikerResponse {
    pub moniker: String,
}

impl fidl::Persistable for IntrospectorGetMonikerResponse {}

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

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

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

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

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

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

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

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

#[derive(Clone, Debug, PartialEq)]
pub struct RealmDestroyChildRequest {
    pub child: fidl_fuchsia_component_decl::ChildRef,
}

impl fidl::Persistable for RealmDestroyChildRequest {}

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

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

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

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

#[derive(Debug, PartialEq)]
pub struct RealmOpenExposedDirRequest {
    pub child: fidl_fuchsia_component_decl::ChildRef,
    pub exposed_dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
}

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

/// 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<fidl::Channel>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    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<fidl_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<fidl_fuchsia_component_decl::Offer>>,
    /// The controller for this component, which may be used to influence the
    /// component's lifecycle.
    pub controller: Option<fidl::endpoints::ServerEnd<ControllerMarker>>,
    /// A dictionary that contains extra capabilities for the component instance.
    pub dictionary: Option<fidl_fuchsia_component_sandbox::DictionaryRef>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> 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<fidl::endpoints::ClientEnd<fidl_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<fidl::EventPair>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

/// Payload for Destroyed events.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct DestroyedPayload {
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for DestroyedPayload {}

/// Payload for DirectoryReady events
#[derive(Debug, Default, PartialEq)]
pub struct DirectoryReadyPayload {
    /// The name of the capability.
    pub name: Option<String>,
    /// Channel to the directory capability.
    pub node: Option<fidl::endpoints::ClientEnd<fidl_fuchsia_io::NodeMarker>>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

/// Payload for Discovered events.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct DiscoveredPayload {
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for DiscoveredPayload {}

/// 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<fidl::encoding::DefaultFuchsiaResourceDialect> for Event {}

/// A head providing metadata about a target component instance.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct EventHeader {
    /// Event type corresponding to the event
    pub event_type: Option<EventType>,
    /// Relative moniker identifying the component instance. Relative to the scope of the event.
    pub moniker: Option<String>,
    /// URL used to resolve the component.
    pub component_url: Option<String>,
    /// Boot time when the event occurred.
    pub timestamp: Option<fidl::BootInstant>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for EventHeader {}

/// 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<fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

/// Payload for Purged events.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct PurgedPayload {
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for PurgedPayload {}

/// Payload for Resolved events.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct ResolvedPayload {
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for ResolvedPayload {}

#[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<fidl_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.
    pub dictionary: Option<fidl_fuchsia_component_sandbox::DictionaryRef>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

/// Payload for Started events.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct StartedPayload {
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for StartedPayload {}

/// Payload for Stopped events.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct StoppedPayload {
    /// The epitaph set on the fuchsia.component.runner/ComponentController
    /// protocol channel. This is the exit status of the component. The
    /// possible status values and their meaning are described in the definition
    /// of the ComponentController protocol.
    pub status: Option<i32>,
    /// The exit code of the component instance. Note that not all components
    /// will stop with an exit code.
    ///
    /// Many program runtimes have the concept of an exit code. Runners may map
    /// that value to this field when applicable. For example, the ELF runner
    /// will publish the Zircon process return code here.
    pub exit_code: Option<i64>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for StoppedPayload {}

/// Payload for Unresolved events.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct UnresolvedPayload {
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for UnresolvedPayload {}

/// 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 DirectoryReady events
    DirectoryReady(DirectoryReadyPayload),
    /// 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::DirectoryReady(x), Self::DirectoryReady(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::DirectoryReady(_) => 3,
            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<fidl::encoding::DefaultFuchsiaResourceDialect> for EventPayload {}

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

impl fidl::endpoints::ProtocolMarker for BinderMarker {
    type Proxy = BinderProxy;
    type RequestStream = BinderRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = BinderSynchronousProxy;

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

pub trait BinderProxyInterface: Send + Sync {}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct BinderSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for BinderSynchronousProxy {
    type Proxy = BinderProxy;
    type Protocol = BinderMarker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl BinderSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <BinderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

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

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

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

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

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

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

impl BinderProxy {
    /// Create a new Proxy for fuchsia.component/Binder.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <BinderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

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

impl BinderProxyInterface for BinderProxy {}

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

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: <fidl::encoding::DefaultFuchsiaResourceDialect 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 fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

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

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

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

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

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

impl futures::Stream for 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::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))))
                    }
                }

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <BinderMarker as fidl::endpoints::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<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl fidl::endpoints::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) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

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

impl BinderControlHandle {}

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

impl fidl::endpoints::ProtocolMarker for ChildIteratorMarker {
    type Proxy = ChildIteratorProxy;
    type RequestStream = ChildIteratorRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ChildIteratorSynchronousProxy;

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

pub trait ChildIteratorProxyInterface: Send + Sync {
    type NextResponseFut: std::future::Future<
            Output = Result<Vec<fidl_fuchsia_component_decl::ChildRef>, fidl::Error>,
        > + Send;
    fn r#next(&self) -> Self::NextResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ChildIteratorSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ChildIteratorSynchronousProxy {
    type Proxy = ChildIteratorProxy;
    type Protocol = ChildIteratorMarker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl ChildIteratorSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <ChildIteratorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

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

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Vec<fidl_fuchsia_component_decl::ChildRef>, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, ChildIteratorNextResponse>(
                (),
                0x40e4c3882b050d08,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.children)
    }
}

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

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

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

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

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

impl ChildIteratorProxy {
    /// Create a new Proxy for fuchsia.component/ChildIterator.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <ChildIteratorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> 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<fidl_fuchsia_component_decl::ChildRef>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ChildIteratorProxyInterface::r#next(self)
    }
}

impl ChildIteratorProxyInterface for ChildIteratorProxy {
    type NextResponseFut = fidl::client::QueryResponseFut<
        Vec<fidl_fuchsia_component_decl::ChildRef>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#next(&self) -> Self::NextResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<fidl_fuchsia_component_decl::ChildRef>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ChildIteratorNextResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x40e4c3882b050d08,
            >(_buf?)?;
            Ok(_response.children)
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            Vec<fidl_fuchsia_component_decl::ChildRef>,
        >(
            (),
            0x40e4c3882b050d08,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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: <fidl::encoding::DefaultFuchsiaResourceDialect 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 fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

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

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

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

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

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

impl futures::Stream for 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::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))))
                    }
                }

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x40e4c3882b050d08 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            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 fidl::endpoints::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<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl fidl::endpoints::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) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

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

impl 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 fidl::endpoints::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: &[fidl_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: &[fidl_fuchsia_component_decl::ChildRef],
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(children);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut children: &[fidl_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 fidl::endpoints::ProtocolMarker for ControllerMarker {
    type Proxy = ControllerProxy;
    type RequestStream = ControllerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ControllerSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) Controller";
}
pub type ControllerStartResult = Result<(), Error>;
pub type ControllerIsStartedResult = Result<bool, Error>;
pub type ControllerGetExposedDictionaryResult =
    Result<fidl_fuchsia_component_sandbox::DictionaryRef, 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: fidl::endpoints::ServerEnd<ExecutionControllerMarker>,
    ) -> Self::StartResponseFut;
    type IsStartedResponseFut: std::future::Future<Output = Result<ControllerIsStartedResult, fidl::Error>>
        + Send;
    fn r#is_started(&self) -> Self::IsStartedResponseFut;
    type GetExposedDictionaryResponseFut: std::future::Future<Output = Result<ControllerGetExposedDictionaryResult, fidl::Error>>
        + Send;
    fn r#get_exposed_dictionary(&self) -> Self::GetExposedDictionaryResponseFut;
    type DestroyResponseFut: std::future::Future<Output = Result<ControllerDestroyResult, fidl::Error>>
        + Send;
    fn r#destroy(&self) -> Self::DestroyResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ControllerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ControllerSynchronousProxy {
    type Proxy = ControllerProxy;
    type Protocol = ControllerMarker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl ControllerSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <ControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

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

    /// 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: fidl::endpoints::ServerEnd<ExecutionControllerMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ControllerStartResult, fidl::Error> {
        let _response = self.client.send_query::<
            ControllerStartRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
        >(
            (&mut args, execution_controller,),
            0x68878076b8d2eac5,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<ControllerMarker>("start")?;
        Ok(_response.map(|x| x))
    }

    /// Returns true if this instance is currently running.
    pub fn r#is_started(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ControllerIsStartedResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::FlexibleResultType<ControllerIsStartedResponse, Error>,
        >(
            (),
            0x2155e6e1db2083c3,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<ControllerMarker>("is_started")?;
        Ok(_response.map(|x| x.is_started))
    }

    /// Returns the dictionary containing the component's exposed capabilities.
    pub fn r#get_exposed_dictionary(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ControllerGetExposedDictionaryResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::FlexibleResultType<ControllerGetExposedDictionaryResponse, Error>,
        >(
            (),
            0x7e48373e5eda1f9b,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<ControllerMarker>("get_exposed_dictionary")?;
        Ok(_response.map(|x| x.dictionary))
    }

    /// Destroys this component. When this method returns, either:
    ///
    /// - Ok was returned, indicating destruction has begun.
    /// - An error was returned, and destruction will not be attempted.
    ///
    /// If Ok was returned, destruction will proceed in the background, but it
    /// hasn't necessarily completed yet. When it completes, the framework will
    /// close this [Controller] channel.
    ///
    /// Errors:
    ///
    /// - `ACCESS_DENIED`: Destruction of this component is not allowed.
    /// Currently, this can happen if the component is a static child of its
    /// parent.
    pub fn r#destroy(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ControllerDestroyResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
        >(
            (),
            0x74529fa68b5c1741,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<ControllerMarker>("destroy")?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl ControllerProxy {
    /// Create a new Proxy for fuchsia.component/Controller.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <ControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> 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: fidl::endpoints::ServerEnd<ExecutionControllerMarker>,
    ) -> fidl::client::QueryResponseFut<
        ControllerStartResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ControllerProxyInterface::r#is_started(self)
    }

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

    /// Destroys this component. When this method returns, either:
    ///
    /// - Ok was returned, indicating destruction has begun.
    /// - An error was returned, and destruction will not be attempted.
    ///
    /// If Ok was returned, destruction will proceed in the background, but it
    /// hasn't necessarily completed yet. When it completes, the framework will
    /// close this [Controller] channel.
    ///
    /// Errors:
    ///
    /// - `ACCESS_DENIED`: Destruction of this component is not allowed.
    /// Currently, this can happen if the component is a static child of its
    /// parent.
    pub fn r#destroy(
        &self,
    ) -> fidl::client::QueryResponseFut<
        ControllerDestroyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ControllerProxyInterface::r#destroy(self)
    }
}

impl ControllerProxyInterface for ControllerProxy {
    type StartResponseFut = fidl::client::QueryResponseFut<
        ControllerStartResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#start(
        &self,
        mut args: StartChildArgs,
        mut execution_controller: fidl::endpoints::ServerEnd<ExecutionControllerMarker>,
    ) -> Self::StartResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x68878076b8d2eac5,
            >(_buf?)?
            .into_result::<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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#is_started(&self) -> Self::IsStartedResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ControllerIsStartedResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<ControllerIsStartedResponse, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2155e6e1db2083c3,
            >(_buf?)?
            .into_result::<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 GetExposedDictionaryResponseFut = fidl::client::QueryResponseFut<
        ControllerGetExposedDictionaryResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_exposed_dictionary(&self) -> Self::GetExposedDictionaryResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ControllerGetExposedDictionaryResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<ControllerGetExposedDictionaryResponse, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7e48373e5eda1f9b,
            >(_buf?)?
            .into_result::<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 DestroyResponseFut = fidl::client::QueryResponseFut<
        ControllerDestroyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#destroy(&self) -> Self::DestroyResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x74529fa68b5c1741,
            >(_buf?)?
            .into_result::<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<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

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: <fidl::encoding::DefaultFuchsiaResourceDialect 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 fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

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

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

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

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

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

impl futures::Stream for 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::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))))
                    }
                }

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x68878076b8d2eac5 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ControllerStartRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            },
                        })
                    }
                    0x7e48373e5eda1f9b => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ControllerControlHandle { inner: this.inner.clone() };
                        Ok(ControllerRequest::GetExposedDictionary {
                            responder: ControllerGetExposedDictionaryResponder {
                                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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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 fidl::endpoints::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: fidl::endpoints::ServerEnd<ExecutionControllerMarker>,
        responder: ControllerStartResponder,
    },
    /// Returns true if this instance is currently running.
    IsStarted { responder: ControllerIsStartedResponder },
    /// Returns the dictionary containing the component's exposed capabilities.
    GetExposedDictionary { responder: ControllerGetExposedDictionaryResponder },
    /// Destroys this component. When this method returns, either:
    ///
    /// - Ok was returned, indicating destruction has begun.
    /// - An error was returned, and destruction will not be attempted.
    ///
    /// If Ok was returned, destruction will proceed in the background, but it
    /// hasn't necessarily completed yet. When it completes, the framework will
    /// close this [Controller] channel.
    ///
    /// Errors:
    ///
    /// - `ACCESS_DENIED`: Destruction of this component is not allowed.
    /// Currently, this can happen if the component is a static child of its
    /// parent.
    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,
        fidl::endpoints::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_get_exposed_dictionary(self) -> Option<(ControllerGetExposedDictionaryResponder)> {
        if let ControllerRequest::GetExposedDictionary { 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::GetExposedDictionary { .. } => "get_exposed_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<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl fidl::endpoints::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) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

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

impl 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 fidl::endpoints::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 fidl::endpoints::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 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 fidl::endpoints::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<fidl_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<fidl_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<fidl_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 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 fidl::endpoints::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 fidl::endpoints::ProtocolMarker for EventStreamMarker {
    type Proxy = EventStreamProxy;
    type RequestStream = EventStreamRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = EventStreamSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.component.EventStream";
}
impl fidl::endpoints::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)]
#[cfg(target_os = "fuchsia")]
pub struct EventStreamSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for EventStreamSynchronousProxy {
    type Proxy = EventStreamProxy;
    type Protocol = EventStreamMarker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl EventStreamSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <EventStreamMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

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

    pub fn r#get_next(&self, ___deadline: zx::MonotonicInstant) -> Result<Vec<Event>, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, EventStreamGetNextResponse>(
                (),
                0x3f24c9495978eb86,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.events)
    }

    /// 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, ___deadline: zx::MonotonicInstant) -> Result<(), fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::EmptyPayload>(
                (),
                0x31331f9578d2e682,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }
}

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

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

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

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

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

impl EventStreamProxy {
    /// Create a new Proxy for fuchsia.component/EventStream.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <EventStreamMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

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

    pub fn r#get_next(
        &self,
    ) -> fidl::client::QueryResponseFut<Vec<Event>, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        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<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        EventStreamProxyInterface::r#wait_for_ready(self)
    }
}

impl EventStreamProxyInterface for EventStreamProxy {
    type GetNextResponseFut =
        fidl::client::QueryResponseFut<Vec<Event>, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#get_next(&self) -> Self::GetNextResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<Event>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                EventStreamGetNextResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#wait_for_ready(&self) -> Self::WaitForReadyResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

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: <fidl::encoding::DefaultFuchsiaResourceDialect 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 fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

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

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

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

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

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

impl futures::Stream for 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::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))))
                    }
                }

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x3f24c9495978eb86 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = 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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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 fidl::endpoints::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<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl fidl::endpoints::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) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

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

impl 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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::ProtocolMarker for ExecutionControllerMarker {
    type Proxy = ExecutionControllerProxy;
    type RequestStream = ExecutionControllerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ExecutionControllerSynchronousProxy;

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

pub trait ExecutionControllerProxyInterface: Send + Sync {
    fn r#stop(&self) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ExecutionControllerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ExecutionControllerSynchronousProxy {
    type Proxy = ExecutionControllerProxy;
    type Protocol = ExecutionControllerMarker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl ExecutionControllerSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <ExecutionControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

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

    /// 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> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x56d23cec21036117,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

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

impl ExecutionControllerProxy {
    /// Create a new Proxy for fuchsia.component/ExecutionController.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <ExecutionControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> 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<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

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: <fidl::encoding::DefaultFuchsiaResourceDialect 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,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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 fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

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

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

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

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

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

impl futures::Stream for 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::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))))
                    }
                }

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

                std::task::Poll::Ready(Some(match header.ordinal {
                0x56d23cec21036117 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = 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 fidl::endpoints::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<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl fidl::endpoints::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) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

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

impl 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 fidl::endpoints::ProtocolMarker for IntrospectorMarker {
    type Proxy = IntrospectorProxy;
    type RequestStream = IntrospectorRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = IntrospectorSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.component.Introspector";
}
impl fidl::endpoints::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: fidl::Event) -> Self::GetMonikerResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct IntrospectorSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for IntrospectorSynchronousProxy {
    type Proxy = IntrospectorProxy;
    type Protocol = IntrospectorMarker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl IntrospectorSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <IntrospectorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

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

    /// 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: fidl::Event,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<IntrospectorGetMonikerResult, fidl::Error> {
        let _response = self.client.send_query::<
            IntrospectorGetMonikerRequest,
            fidl::encoding::FlexibleResultType<IntrospectorGetMonikerResponse, Error>,
        >(
            (component_instance,),
            0x2f980ceb37bf458,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<IntrospectorMarker>("get_moniker")?;
        Ok(_response.map(|x| x.moniker))
    }
}

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

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

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

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

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

impl IntrospectorProxy {
    /// Create a new Proxy for fuchsia.component/Introspector.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <IntrospectorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> 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: fidl::Event,
    ) -> fidl::client::QueryResponseFut<
        IntrospectorGetMonikerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        IntrospectorProxyInterface::r#get_moniker(self, component_instance)
    }
}

impl IntrospectorProxyInterface for IntrospectorProxy {
    type GetMonikerResponseFut = fidl::client::QueryResponseFut<
        IntrospectorGetMonikerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_moniker(&self, mut component_instance: fidl::Event) -> Self::GetMonikerResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<IntrospectorGetMonikerResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<IntrospectorGetMonikerResponse, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2f980ceb37bf458,
            >(_buf?)?
            .into_result::<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<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

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: <fidl::encoding::DefaultFuchsiaResourceDialect 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 fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

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

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

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

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

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

impl futures::Stream for 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::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))))
                    }
                }

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x2f980ceb37bf458 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            IntrospectorGetMonikerRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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 fidl::endpoints::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: fidl::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<(fidl::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<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl fidl::endpoints::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) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

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

impl 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 fidl::endpoints::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 fidl::endpoints::ProtocolMarker for NamespaceMarker {
    type Proxy = NamespaceProxy;
    type RequestStream = NamespaceRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = NamespaceSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.component.Namespace";
}
impl fidl::endpoints::DiscoverableProtocolMarker for NamespaceMarker {}
pub type NamespaceCreateResult = 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;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct NamespaceSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for NamespaceSynchronousProxy {
    type Proxy = NamespaceProxy;
    type Protocol = NamespaceMarker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl NamespaceSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <NamespaceMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

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

    pub fn r#create(
        &self,
        mut entries: Vec<NamespaceInputEntry>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<NamespaceCreateResult, fidl::Error> {
        let _response = self.client.send_query::<
            NamespaceCreateRequest,
            fidl::encoding::FlexibleResultType<NamespaceCreateResponse, NamespaceError>,
        >(
            (entries.as_mut(),),
            0x4329fe12b2a790f9,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<NamespaceMarker>("create")?;
        Ok(_response.map(|x| x.entries))
    }
}

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

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

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

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

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

impl NamespaceProxy {
    /// Create a new Proxy for fuchsia.component/Namespace.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <NamespaceMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

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

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

impl NamespaceProxyInterface for NamespaceProxy {
    type CreateResponseFut = fidl::client::QueryResponseFut<
        NamespaceCreateResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#create(&self, mut entries: Vec<NamespaceInputEntry>) -> Self::CreateResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NamespaceCreateResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<NamespaceCreateResponse, NamespaceError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4329fe12b2a790f9,
            >(_buf?)?
            .into_result::<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,
        )
    }
}

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

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: <fidl::encoding::DefaultFuchsiaResourceDialect 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 fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

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

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

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

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

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

impl futures::Stream for 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::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))))
                    }
                }

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x4329fe12b2a790f9 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NamespaceCreateRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            },
                        })
                    }
                    _ 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 fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

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

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            NamespaceRequest::Create { .. } => "create",
            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<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl fidl::endpoints::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) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

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

impl 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 fidl::endpoints::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,
        )
    }
}

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

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

    const DEBUG_NAME: &'static str = "fuchsia.component.Realm";
}
impl fidl::endpoints::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 trait RealmProxyInterface: Send + Sync {
    type OpenControllerResponseFut: std::future::Future<Output = Result<RealmOpenControllerResult, fidl::Error>>
        + Send;
    fn r#open_controller(
        &self,
        child: &fidl_fuchsia_component_decl::ChildRef,
        controller: fidl::endpoints::ServerEnd<ControllerMarker>,
    ) -> Self::OpenControllerResponseFut;
    type OpenExposedDirResponseFut: std::future::Future<Output = Result<RealmOpenExposedDirResult, fidl::Error>>
        + Send;
    fn r#open_exposed_dir(
        &self,
        child: &fidl_fuchsia_component_decl::ChildRef,
        exposed_dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
    ) -> Self::OpenExposedDirResponseFut;
    type CreateChildResponseFut: std::future::Future<Output = Result<RealmCreateChildResult, fidl::Error>>
        + Send;
    fn r#create_child(
        &self,
        collection: &fidl_fuchsia_component_decl::CollectionRef,
        decl: &fidl_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: &fidl_fuchsia_component_decl::ChildRef,
    ) -> Self::DestroyChildResponseFut;
    type ListChildrenResponseFut: std::future::Future<Output = Result<RealmListChildrenResult, fidl::Error>>
        + Send;
    fn r#list_children(
        &self,
        collection: &fidl_fuchsia_component_decl::CollectionRef,
        iter: fidl::endpoints::ServerEnd<ChildIteratorMarker>,
    ) -> Self::ListChildrenResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct RealmSynchronousProxy {
    client: fidl::client::sync::Client,
}

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

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

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

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

#[cfg(target_os = "fuchsia")]
impl RealmSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <RealmMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

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

    /// 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: &fidl_fuchsia_component_decl::ChildRef,
        mut controller: fidl::endpoints::ServerEnd<ControllerMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RealmOpenControllerResult, fidl::Error> {
        let _response = self.client.send_query::<
            RealmOpenControllerRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
        >(
            (child, controller,),
            0x7150b7898d1b1180,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Opens the exposed directory of a child component instance. 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. Instead, starting will occur iff the parent binds
    /// to one of the capabilities contained within `exposed_dir`.
    ///
    /// `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: &fidl_fuchsia_component_decl::ChildRef,
        mut exposed_dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RealmOpenExposedDirResult, fidl::Error> {
        let _response = self.client.send_query::<
            RealmOpenExposedDirRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
        >(
            (child, exposed_dir,),
            0x7f993235ca59f92c,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// 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: &fidl_fuchsia_component_decl::CollectionRef,
        mut decl: &fidl_fuchsia_component_decl::Child,
        mut args: CreateChildArgs,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RealmCreateChildResult, fidl::Error> {
        let _response = self.client.send_query::<
            RealmCreateChildRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
        >(
            (collection, decl, &mut args,),
            0x43e48ce8483d7560,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// 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: &fidl_fuchsia_component_decl::ChildRef,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RealmDestroyChildResult, fidl::Error> {
        let _response = self.client.send_query::<
            RealmDestroyChildRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
        >(
            (child,),
            0x71d8caf8850c9222,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// 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: &fidl_fuchsia_component_decl::CollectionRef,
        mut iter: fidl::endpoints::ServerEnd<ChildIteratorMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RealmListChildrenResult, fidl::Error> {
        let _response = self.client.send_query::<
            RealmListChildrenRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
        >(
            (collection, iter,),
            0x6888a76683efc0a1,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl RealmProxy {
    /// Create a new Proxy for fuchsia.component/Realm.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <RealmMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

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

    /// 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: &fidl_fuchsia_component_decl::ChildRef,
        mut controller: fidl::endpoints::ServerEnd<ControllerMarker>,
    ) -> fidl::client::QueryResponseFut<
        RealmOpenControllerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RealmProxyInterface::r#open_controller(self, child, controller)
    }

    /// Opens the exposed directory of a child component instance. 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. Instead, starting will occur iff the parent binds
    /// to one of the capabilities contained within `exposed_dir`.
    ///
    /// `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: &fidl_fuchsia_component_decl::ChildRef,
        mut exposed_dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
    ) -> fidl::client::QueryResponseFut<
        RealmOpenExposedDirResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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: &fidl_fuchsia_component_decl::CollectionRef,
        mut decl: &fidl_fuchsia_component_decl::Child,
        mut args: CreateChildArgs,
    ) -> fidl::client::QueryResponseFut<
        RealmCreateChildResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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: &fidl_fuchsia_component_decl::ChildRef,
    ) -> fidl::client::QueryResponseFut<
        RealmDestroyChildResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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: &fidl_fuchsia_component_decl::CollectionRef,
        mut iter: fidl::endpoints::ServerEnd<ChildIteratorMarker>,
    ) -> fidl::client::QueryResponseFut<
        RealmListChildrenResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RealmProxyInterface::r#list_children(self, collection, iter)
    }
}

impl RealmProxyInterface for RealmProxy {
    type OpenControllerResponseFut = fidl::client::QueryResponseFut<
        RealmOpenControllerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#open_controller(
        &self,
        mut child: &fidl_fuchsia_component_decl::ChildRef,
        mut controller: fidl::endpoints::ServerEnd<ControllerMarker>,
    ) -> Self::OpenControllerResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#open_exposed_dir(
        &self,
        mut child: &fidl_fuchsia_component_decl::ChildRef,
        mut exposed_dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
    ) -> Self::OpenExposedDirResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#create_child(
        &self,
        mut collection: &fidl_fuchsia_component_decl::CollectionRef,
        mut decl: &fidl_fuchsia_component_decl::Child,
        mut args: CreateChildArgs,
    ) -> Self::CreateChildResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#destroy_child(
        &self,
        mut child: &fidl_fuchsia_component_decl::ChildRef,
    ) -> Self::DestroyChildResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#list_children(
        &self,
        mut collection: &fidl_fuchsia_component_decl::CollectionRef,
        mut iter: fidl::endpoints::ServerEnd<ChildIteratorMarker>,
    ) -> Self::ListChildrenResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6888a76683efc0a1,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<RealmListChildrenRequest, RealmListChildrenResult>(
            (collection, iter),
            0x6888a76683efc0a1,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x7150b7898d1b1180 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RealmOpenControllerRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name: <RealmMarker as fidl::endpoints::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: fidl_fuchsia_component_decl::ChildRef,
        controller: fidl::endpoints::ServerEnd<ControllerMarker>,
        responder: RealmOpenControllerResponder,
    },
    /// Opens the exposed directory of a child component instance. 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. Instead, starting will occur iff the parent binds
    /// to one of the capabilities contained within `exposed_dir`.
    ///
    /// `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: fidl_fuchsia_component_decl::ChildRef,
        exposed_dir: fidl::endpoints::ServerEnd<fidl_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: fidl_fuchsia_component_decl::CollectionRef,
        decl: fidl_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: fidl_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: fidl_fuchsia_component_decl::CollectionRef,
        iter: fidl::endpoints::ServerEnd<ChildIteratorMarker>,
        responder: RealmListChildrenResponder,
    },
}

impl RealmRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_open_controller(
        self,
    ) -> Option<(
        fidl_fuchsia_component_decl::ChildRef,
        fidl::endpoints::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<(
        fidl_fuchsia_component_decl::ChildRef,
        fidl::endpoints::ServerEnd<fidl_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<(
        fidl_fuchsia_component_decl::CollectionRef,
        fidl_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<(fidl_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<(
        fidl_fuchsia_component_decl::CollectionRef,
        fidl::endpoints::ServerEnd<ChildIteratorMarker>,
        RealmListChildrenResponder,
    )> {
        if let RealmRequest::ListChildren { collection, iter, responder } = self {
            Some((collection, iter, 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",
        }
    }
}

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

impl fidl::endpoints::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) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

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

impl RealmControlHandle {}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct 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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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(),
            )
    }
}

mod internal {
    use super::*;
    unsafe impl fidl::encoding::TypeMarker for Error {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u32>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            false
        }

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

    impl fidl::encoding::ValueTypeMarker for Error {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Error {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Error {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::unknown()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);

            *self = Self::from_primitive_allow_unknown(prim);
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for EventType {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u32>()
        }

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

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

    impl fidl::encoding::ValueTypeMarker for EventType {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for EventType {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EventType {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::CapabilityRequested
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for NamespaceError {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u32>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            false
        }

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

    impl fidl::encoding::ValueTypeMarker for NamespaceError {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for NamespaceError {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NamespaceError {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::unknown()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);

            *self = Self::from_primitive_allow_unknown(prim);
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for ChildIteratorNextResponse {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ChildIteratorNextResponse {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<ChildIteratorNextResponse, D> for &ChildIteratorNextResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ChildIteratorNextResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ChildIteratorNextResponse, D>::encode(
                (
                    <fidl::encoding::Vector<fidl_fuchsia_component_decl::ChildRef, 128> as fidl::encoding::ValueTypeMarker>::borrow(&self.children),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<
                fidl::encoding::Vector<fidl_fuchsia_component_decl::ChildRef, 128>,
                D,
            >,
        > fidl::encoding::Encode<ChildIteratorNextResponse, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ChildIteratorNextResponse>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for ChildIteratorNextResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                children: fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_component_decl::ChildRef, 128>, D),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_component_decl::ChildRef, 128>, D, &mut self.children, 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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ControllerStartRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ControllerStartRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ControllerStartRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <StartChildArgs as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.args),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ExecutionControllerMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.execution_controller),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<StartChildArgs, fidl::encoding::DefaultFuchsiaResourceDialect>,
            T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ExecutionControllerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            ControllerStartRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ControllerStartRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                args: fidl::new_empty!(
                    StartChildArgs,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                execution_controller: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ExecutionControllerMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(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,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.args,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ExecutionControllerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ControllerGetExposedDictionaryResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ControllerGetExposedDictionaryResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ControllerGetExposedDictionaryResponse, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl_fuchsia_component_sandbox::DictionaryRef as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.dictionary),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl_fuchsia_component_sandbox::DictionaryRef,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            ControllerGetExposedDictionaryResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ControllerGetExposedDictionaryResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                dictionary: fidl::new_empty!(
                    fidl_fuchsia_component_sandbox::DictionaryRef,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl_fuchsia_component_sandbox::DictionaryRef,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ControllerIsStartedResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ControllerIsStartedResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                ControllerIsStartedResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.is_started),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<T0: fidl::encoding::Encode<bool, fidl::encoding::DefaultFuchsiaResourceDialect>>
        fidl::encoding::Encode<
            ControllerIsStartedResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ControllerIsStartedResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                is_started: fidl::new_empty!(bool, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                bool,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut EventStreamGetNextResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<EventStreamGetNextResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<EventStreamGetNextResponse, fidl::encoding::DefaultFuchsiaResourceDialect>::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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            EventStreamGetNextResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for EventStreamGetNextResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                events: fidl::new_empty!(
                    fidl::encoding::UnboundedVector<Event>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ValueTypeMarker for ExecutionControllerOnStopRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ExecutionControllerOnStopRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<ExecutionControllerOnStopRequest, D>
        for &ExecutionControllerOnStopRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ExecutionControllerOnStopRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ExecutionControllerOnStopRequest, D>::encode(
                (<StoppedPayload as fidl::encoding::ValueTypeMarker>::borrow(
                    &self.stopped_payload,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<StoppedPayload, D>>
        fidl::encoding::Encode<ExecutionControllerOnStopRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ExecutionControllerOnStopRequest>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for ExecutionControllerOnStopRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { stopped_payload: fidl::new_empty!(StoppedPayload, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                StoppedPayload,
                D,
                &mut self.stopped_payload,
                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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut IntrospectorGetMonikerRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<IntrospectorGetMonikerRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                IntrospectorGetMonikerRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<fidl::encoding::HandleType<
                    fidl::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<
                    fidl::Event,
                    { fidl::ObjectType::EVENT.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            IntrospectorGetMonikerRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for IntrospectorGetMonikerRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                component_instance: fidl::new_empty!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

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

    impl fidl::encoding::ValueTypeMarker for IntrospectorGetMonikerResponse {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for IntrospectorGetMonikerResponse {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<IntrospectorGetMonikerResponse, D>
        for &IntrospectorGetMonikerResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<IntrospectorGetMonikerResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<IntrospectorGetMonikerResponse, D>::encode(
                (<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(
                    &self.moniker,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
        > fidl::encoding::Encode<IntrospectorGetMonikerResponse, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<IntrospectorGetMonikerResponse>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for IntrospectorGetMonikerResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { moniker: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::BoundedString<4096>,
                D,
                &mut self.moniker,
                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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut NamespaceCreateRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NamespaceCreateRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<NamespaceCreateRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            NamespaceCreateRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for NamespaceCreateRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                entries: fidl::new_empty!(
                    fidl::encoding::UnboundedVector<NamespaceInputEntry>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::UnboundedVector<NamespaceInputEntry>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut NamespaceInputEntry
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NamespaceInputEntry>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<NamespaceInputEntry, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::BoundedString<4095> as fidl::encoding::ValueTypeMarker>::borrow(&self.path),
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<fidl_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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<
                    fidl::endpoints::ClientEnd<fidl_fuchsia_component_sandbox::DictionaryMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<NamespaceInputEntry, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for NamespaceInputEntry
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                path: fidl::new_empty!(
                    fidl::encoding::BoundedString<4095>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                dictionary: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<
                            fidl_fuchsia_component_sandbox::DictionaryMarker,
                        >,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.path,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<
                    fidl::endpoints::ClientEnd<fidl_fuchsia_component_sandbox::DictionaryMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.dictionary,
                decoder,
                offset + 16,
                _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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut NamespaceCreateResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NamespaceCreateResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<NamespaceCreateResponse, fidl::encoding::DefaultFuchsiaResourceDialect>::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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            NamespaceCreateResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for NamespaceCreateResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                entries: fidl::new_empty!(
                    fidl::encoding::UnboundedVector<NamespaceEntry>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::UnboundedVector<NamespaceEntry>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut RealmCreateChildRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RealmCreateChildRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RealmCreateChildRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl_fuchsia_component_decl::CollectionRef as fidl::encoding::ValueTypeMarker>::borrow(&self.collection),
                    <fidl_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<
                fidl_fuchsia_component_decl::CollectionRef,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<
                fidl_fuchsia_component_decl::Child,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T2: fidl::encoding::Encode<CreateChildArgs, fidl::encoding::DefaultFuchsiaResourceDialect>,
        >
        fidl::encoding::Encode<
            RealmCreateChildRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for RealmCreateChildRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                collection: fidl::new_empty!(
                    fidl_fuchsia_component_decl::CollectionRef,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                decl: fidl::new_empty!(
                    fidl_fuchsia_component_decl::Child,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                args: fidl::new_empty!(
                    CreateChildArgs,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ValueTypeMarker for RealmDestroyChildRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for RealmDestroyChildRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<RealmDestroyChildRequest, D> for &RealmDestroyChildRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RealmDestroyChildRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RealmDestroyChildRequest, D>::encode(
                (
                    <fidl_fuchsia_component_decl::ChildRef as fidl::encoding::ValueTypeMarker>::borrow(&self.child),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<fidl_fuchsia_component_decl::ChildRef, D>,
        > fidl::encoding::Encode<RealmDestroyChildRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RealmDestroyChildRequest>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for RealmDestroyChildRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { child: fidl::new_empty!(fidl_fuchsia_component_decl::ChildRef, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl_fuchsia_component_decl::ChildRef,
                D,
                &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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut RealmListChildrenRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RealmListChildrenRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RealmListChildrenRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl_fuchsia_component_decl::CollectionRef as fidl::encoding::ValueTypeMarker>::borrow(&self.collection),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ChildIteratorMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.iter),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl_fuchsia_component_decl::CollectionRef,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ChildIteratorMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            RealmListChildrenRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for RealmListChildrenRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                collection: fidl::new_empty!(
                    fidl_fuchsia_component_decl::CollectionRef,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                iter: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ChildIteratorMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(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_fuchsia_component_decl::CollectionRef,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.collection,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ChildIteratorMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut RealmOpenControllerRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RealmOpenControllerRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RealmOpenControllerRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl_fuchsia_component_decl::ChildRef as fidl::encoding::ValueTypeMarker>::borrow(&self.child),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ControllerMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.controller),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl_fuchsia_component_decl::ChildRef,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ControllerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            RealmOpenControllerRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for RealmOpenControllerRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                child: fidl::new_empty!(
                    fidl_fuchsia_component_decl::ChildRef,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                controller: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ControllerMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(32) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl_fuchsia_component_decl::ChildRef,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.child,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ControllerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut RealmOpenExposedDirRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RealmOpenExposedDirRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RealmOpenExposedDirRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl_fuchsia_component_decl::ChildRef as fidl::encoding::ValueTypeMarker>::borrow(&self.child),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.exposed_dir),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl_fuchsia_component_decl::ChildRef,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<
                    fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            RealmOpenExposedDirRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for RealmOpenExposedDirRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                child: fidl::new_empty!(
                    fidl_fuchsia_component_decl::ChildRef,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                exposed_dir: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(32) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl_fuchsia_component_decl::ChildRef,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.child,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<
                    fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.exposed_dir,
                decoder,
                offset + 32,
                _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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut CapabilityRequestedPayload
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                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<
                    fidl::Channel,
                    { fidl::ObjectType::CHANNEL.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.capability.as_mut().map(
                    <fidl::encoding::HandleType<
                        fidl::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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for CapabilityRequestedPayload
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            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>,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::BoundedString<255>,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    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<
                    fidl::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<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
                fidl::decode!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, 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.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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut CreateChildArgs
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            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<fidl_fuchsia_process::HandleInfo, 128>, fidl::encoding::DefaultFuchsiaResourceDialect>(
            self.numbered_handles.as_mut().map(<fidl::encoding::Vector<fidl_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<fidl_fuchsia_component_decl::Offer, 128>, fidl::encoding::DefaultFuchsiaResourceDialect>(
            self.dynamic_offers.as_ref().map(<fidl::encoding::Vector<fidl_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<fidl::endpoints::ServerEnd<ControllerMarker>>, fidl::encoding::DefaultFuchsiaResourceDialect>(
            self.controller.as_mut().map(<fidl::encoding::Endpoint<fidl::endpoints::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::<fidl_fuchsia_component_sandbox::DictionaryRef, fidl::encoding::DefaultFuchsiaResourceDialect>(
            self.dictionary.as_mut().map(<fidl_fuchsia_component_sandbox::DictionaryRef 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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for CreateChildArgs
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            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<
                    fidl_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<fidl_fuchsia_process::HandleInfo, 128>, fidl::encoding::DefaultFuchsiaResourceDialect));
                fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_process::HandleInfo, 128>, fidl::encoding::DefaultFuchsiaResourceDialect, 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<
                    fidl_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<fidl_fuchsia_component_decl::Offer, 128>, fidl::encoding::DefaultFuchsiaResourceDialect));
                fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_component_decl::Offer, 128>, fidl::encoding::DefaultFuchsiaResourceDialect, 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<
                    fidl::endpoints::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<fidl::endpoints::ServerEnd<ControllerMarker>>,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ControllerMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    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_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!(
                        fidl_fuchsia_component_sandbox::DictionaryRef,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl_fuchsia_component_sandbox::DictionaryRef,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut DebugStartedPayload
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            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<
                    fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.runtime_dir.as_mut().map(
                    <fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<fidl_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<
                    fidl::EventPair,
                    { fidl::ObjectType::EVENTPAIR.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.break_on_start.as_mut().map(
                    <fidl::encoding::HandleType<
                        fidl::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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for DebugStartedPayload
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            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<
                    fidl::endpoints::ClientEnd<fidl_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<
                            fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
                        >,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    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<
                    fidl::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<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
                fidl::decode!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, 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 DestroyedPayload {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for DestroyedPayload {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for DestroyedPayload {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DestroyedPayload, D>
        for &DestroyedPayload
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DestroyedPayload>(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;

            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DestroyedPayload {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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;

            // 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 DirectoryReadyPayload {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.node {
                return 2;
            }
            if let Some(_) = self.name {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for DirectoryReadyPayload {
        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 DirectoryReadyPayload {
        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<DirectoryReadyPayload, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut DirectoryReadyPayload
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DirectoryReadyPayload>(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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                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::Endpoint<fidl::endpoints::ClientEnd<fidl_fuchsia_io::NodeMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.node.as_mut().map(
                    <fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<fidl_fuchsia_io::NodeMarker>,
                    > 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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for DirectoryReadyPayload
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            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>,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::BoundedString<255>,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    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<
                    fidl::endpoints::ClientEnd<fidl_fuchsia_io::NodeMarker>,
                > 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.node.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::Endpoint<
                            fidl::endpoints::ClientEnd<fidl_fuchsia_io::NodeMarker>,
                        >,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<fidl_fuchsia_io::NodeMarker>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    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 DiscoveredPayload {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for DiscoveredPayload {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for DiscoveredPayload {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DiscoveredPayload, D>
        for &DiscoveredPayload
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DiscoveredPayload>(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;

            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DiscoveredPayload {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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;

            // 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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut Event
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            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,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                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,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                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, fidl::encoding::DefaultFuchsiaResourceDialect> for Event {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            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, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    EventHeader,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    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, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    EventPayload,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    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 EventHeader {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.timestamp {
                return 4;
            }
            if let Some(_) = self.component_url {
                return 3;
            }
            if let Some(_) = self.moniker {
                return 2;
            }
            if let Some(_) = self.event_type {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for EventHeader {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for EventHeader {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EventHeader, D>
        for &EventHeader
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<EventHeader>(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::<EventType, D>(
                self.event_type
                    .as_ref()
                    .map(<EventType 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::BoundedString<4096>, D>(
            self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> 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::BoundedString<4096>, D>(
            self.component_url.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::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::BootInstant, D>(
                self.timestamp
                    .as_ref()
                    .map(<fidl::BootInstant as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EventHeader {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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 =
                    <EventType 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.event_type.get_or_insert_with(|| fidl::new_empty!(EventType, D));
                fidl::decode!(EventType, D, 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::BoundedString<4096> 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.moniker.get_or_insert_with(|| {
                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
                });
                fidl::decode!(
                    fidl::encoding::BoundedString<4096>,
                    D,
                    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::BoundedString<4096> 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.component_url.get_or_insert_with(|| {
                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
                });
                fidl::decode!(
                    fidl::encoding::BoundedString<4096>,
                    D,
                    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::BootInstant 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.timestamp.get_or_insert_with(|| fidl::new_empty!(fidl::BootInstant, D));
                fidl::decode!(fidl::BootInstant, D, 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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut NamespaceEntry
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            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>, fidl::encoding::DefaultFuchsiaResourceDialect>(
            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<
                    fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.directory.as_mut().map(
                    <fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<fidl_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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for NamespaceEntry
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            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>,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::BoundedString<4095>,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    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<
                    fidl::endpoints::ClientEnd<fidl_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<
                            fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
                        >,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    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 PurgedPayload {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for PurgedPayload {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for PurgedPayload {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PurgedPayload, D>
        for &PurgedPayload
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<PurgedPayload>(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;

            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PurgedPayload {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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;

            // 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 ResolvedPayload {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for ResolvedPayload {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ResolvedPayload {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ResolvedPayload, D>
        for &ResolvedPayload
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ResolvedPayload>(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;

            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ResolvedPayload {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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;

            // 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.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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut StartChildArgs
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            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<fidl_fuchsia_process::HandleInfo, 128>, fidl::encoding::DefaultFuchsiaResourceDialect>(
            self.numbered_handles.as_mut().map(<fidl::encoding::Vector<fidl_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>, fidl::encoding::DefaultFuchsiaResourceDialect>(
            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::<fidl_fuchsia_component_sandbox::DictionaryRef, fidl::encoding::DefaultFuchsiaResourceDialect>(
            self.dictionary.as_mut().map(<fidl_fuchsia_component_sandbox::DictionaryRef 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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for StartChildArgs
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            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<
                    fidl_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<fidl_fuchsia_process::HandleInfo, 128>, fidl::encoding::DefaultFuchsiaResourceDialect));
                fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_process::HandleInfo, 128>, fidl::encoding::DefaultFuchsiaResourceDialect, 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>, fidl::encoding::DefaultFuchsiaResourceDialect));
                fidl::decode!(fidl::encoding::Vector<NamespaceEntry, 32>, fidl::encoding::DefaultFuchsiaResourceDialect, 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_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!(
                        fidl_fuchsia_component_sandbox::DictionaryRef,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl_fuchsia_component_sandbox::DictionaryRef,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    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 StartedPayload {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for StartedPayload {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for StartedPayload {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<StartedPayload, D>
        for &StartedPayload
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<StartedPayload>(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;

            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StartedPayload {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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;

            // 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 StoppedPayload {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.exit_code {
                return 2;
            }
            if let Some(_) = self.status {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for StoppedPayload {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for StoppedPayload {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<StoppedPayload, D>
        for &StoppedPayload
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<StoppedPayload>(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::<i32, D>(
                self.status.as_ref().map(<i32 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::<i64, D>(
                self.exit_code.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StoppedPayload {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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 =
                    <i32 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.status.get_or_insert_with(|| fidl::new_empty!(i32, D));
                fidl::decode!(i32, D, 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 =
                    <i64 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.exit_code.get_or_insert_with(|| fidl::new_empty!(i64, D));
                fidl::decode!(i64, D, 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 UnresolvedPayload {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for UnresolvedPayload {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for UnresolvedPayload {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UnresolvedPayload, D>
        for &UnresolvedPayload
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<UnresolvedPayload>(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;

            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UnresolvedPayload {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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;

            // 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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut EventPayload
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<EventPayload>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
            EventPayload::CapabilityRequested(ref mut val) => {
                fidl::encoding::encode_in_envelope::<CapabilityRequestedPayload, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <CapabilityRequestedPayload as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            EventPayload::Purged(ref val) => {
                fidl::encoding::encode_in_envelope::<PurgedPayload, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <PurgedPayload as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            EventPayload::DirectoryReady(ref mut val) => {
                fidl::encoding::encode_in_envelope::<DirectoryReadyPayload, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <DirectoryReadyPayload as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            EventPayload::Discovered(ref val) => {
                fidl::encoding::encode_in_envelope::<DiscoveredPayload, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <DiscoveredPayload as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            EventPayload::Destroyed(ref val) => {
                fidl::encoding::encode_in_envelope::<DestroyedPayload, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <DestroyedPayload as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            EventPayload::Resolved(ref val) => {
                fidl::encoding::encode_in_envelope::<ResolvedPayload, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <ResolvedPayload as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            EventPayload::Started(ref val) => {
                fidl::encoding::encode_in_envelope::<StartedPayload, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <StartedPayload as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            EventPayload::Stopped(ref val) => {
                fidl::encoding::encode_in_envelope::<StoppedPayload, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <StoppedPayload as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            EventPayload::DebugStarted(ref mut val) => {
                fidl::encoding::encode_in_envelope::<DebugStartedPayload, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <DebugStartedPayload as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            EventPayload::Unresolved(ref val) => {
                fidl::encoding::encode_in_envelope::<UnresolvedPayload, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <UnresolvedPayload as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            EventPayload::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
        }
        }
    }

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

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            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),
                3 => <DirectoryReadyPayload 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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let EventPayload::CapabilityRequested(ref mut val) = self {
                        fidl::decode!(
                            CapabilityRequestedPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let EventPayload::Purged(ref mut val) = self {
                        fidl::decode!(
                            PurgedPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                3 => {
                    #[allow(irrefutable_let_patterns)]
                    if let EventPayload::DirectoryReady(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = EventPayload::DirectoryReady(fidl::new_empty!(
                            DirectoryReadyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let EventPayload::DirectoryReady(ref mut val) = self {
                        fidl::decode!(
                            DirectoryReadyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let EventPayload::Discovered(ref mut val) = self {
                        fidl::decode!(
                            DiscoveredPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let EventPayload::Destroyed(ref mut val) = self {
                        fidl::decode!(
                            DestroyedPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let EventPayload::Resolved(ref mut val) = self {
                        fidl::decode!(
                            ResolvedPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let EventPayload::Started(ref mut val) = self {
                        fidl::decode!(
                            StartedPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let EventPayload::Stopped(ref mut val) = self {
                        fidl::decode!(
                            StoppedPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let EventPayload::DebugStarted(ref mut val) = self {
                        fidl::decode!(
                            DebugStartedPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let EventPayload::Unresolved(ref mut val) = self {
                        fidl::decode!(
                            UnresolvedPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            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(())
        }
    }
}