fidl_fuchsia_element/

fidl_fuchsia_element.rs

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

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

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

/// A list of annotations on an element.
pub type Annotations = Vec<Annotation>;

/// An annotation defined dynamically by key/value pair.
///
/// The Session Framework does not constrain the contents of `key` and `value`
/// in any way. Cooperating components that exchange annotations must define
/// and validate annotation entries based on their own conventions.
#[derive(Debug, PartialEq)]
pub struct Annotation {
    /// An identfier for this annotation.
    pub key: AnnotationKey,
    /// The content of this annotation.
    pub value: AnnotationValue,
}

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

#[derive(Debug, PartialEq)]
pub struct AnnotationControllerUpdateAnnotationsRequest {
    pub annotations_to_set: Vec<Annotation>,
    pub annotations_to_delete: Vec<AnnotationKey>,
}

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

#[derive(Debug, PartialEq)]
pub struct AnnotationControllerGetAnnotationsResponse {
    pub annotations: Vec<Annotation>,
}

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

#[derive(Debug, PartialEq)]
pub struct AnnotationControllerWatchAnnotationsResponse {
    pub annotations: Vec<Annotation>,
}

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

#[derive(Debug, PartialEq)]
pub struct GraphicalPresenterPresentViewRequest {
    pub view_spec: ViewSpec,
    pub annotation_controller: Option<fidl::endpoints::ClientEnd<AnnotationControllerMarker>>,
    pub view_controller_request: Option<fidl::endpoints::ServerEnd<ViewControllerMarker>>,
}

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

#[derive(Debug, PartialEq)]
pub struct ManagerProposeElementRequest {
    pub spec: Spec,
    pub controller: Option<fidl::endpoints::ServerEnd<ControllerMarker>>,
}

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

/// Description of an element to be added to a session.
#[derive(Debug, Default, PartialEq)]
pub struct Spec {
    /// The component URL of the element. Required.
    pub component_url: Option<String>,
    /// Initial annotations on the element. Required, but can be an empty vector. If the element
    /// manager URL annotation is included (which is allowed, but not necessary), then it *must*
    /// match `component_url`.
    pub annotations: Option<Vec<Annotation>>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

/// A description of a view that can be presented by a `GraphicalPresenter`.
#[derive(Debug, Default, PartialEq)]
pub struct ViewSpec {
    /// The view holder token for the presented Gfx view. Must be unset for
    /// Flatland views. One of `view_holder_token` or `viewport_creation_token`
    /// must be set.
    pub view_holder_token: Option<fidl_fuchsia_ui_views::ViewHolderToken>,
    /// The `ViewRef` of the presented Gfx view. Must be unset for Flatland
    /// views.
    pub view_ref: Option<fidl_fuchsia_ui_views::ViewRef>,
    /// The initial annotations associated with the presented view. Updates to
    /// annotations are observed through the `AnnotationController` passed
    /// to `PresentView()`.
    ///
    /// Optional.
    pub annotations: Option<Vec<Annotation>>,
    /// The viewport creation token for the presented Flatland view. Must be
    /// unset for Gfx views. One of `view_holder_token` or `viewport_creation_token`
    /// must be set.
    pub viewport_creation_token: Option<fidl_fuchsia_ui_views::ViewportCreationToken>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

/// The value of an [`fuchsia.element/Annotation`].
///
/// The actual field used depends on the type of annotation.
#[derive(Debug, PartialEq)]
pub enum AnnotationValue {
    Text(String),
    Buffer(fidl_fuchsia_mem::Buffer),
}

impl AnnotationValue {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::Text(_) => 1,
            Self::Buffer(_) => 2,
        }
    }
}

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

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

impl fidl::endpoints::ProtocolMarker for AnnotationControllerMarker {
    type Proxy = AnnotationControllerProxy;
    type RequestStream = AnnotationControllerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = AnnotationControllerSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) AnnotationController";
}
pub type AnnotationControllerUpdateAnnotationsResult = Result<(), UpdateAnnotationsError>;
pub type AnnotationControllerGetAnnotationsResult = Result<Vec<Annotation>, GetAnnotationsError>;
pub type AnnotationControllerWatchAnnotationsResult =
    Result<Vec<Annotation>, WatchAnnotationsError>;

pub trait AnnotationControllerProxyInterface: Send + Sync {
    type UpdateAnnotationsResponseFut: std::future::Future<
            Output = Result<AnnotationControllerUpdateAnnotationsResult, fidl::Error>,
        > + Send;
    fn r#update_annotations(
        &self,
        annotations_to_set: Vec<Annotation>,
        annotations_to_delete: &[AnnotationKey],
    ) -> Self::UpdateAnnotationsResponseFut;
    type GetAnnotationsResponseFut: std::future::Future<Output = Result<AnnotationControllerGetAnnotationsResult, fidl::Error>>
        + Send;
    fn r#get_annotations(&self) -> Self::GetAnnotationsResponseFut;
    type WatchAnnotationsResponseFut: std::future::Future<
            Output = Result<AnnotationControllerWatchAnnotationsResult, fidl::Error>,
        > + Send;
    fn r#watch_annotations(&self) -> Self::WatchAnnotationsResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct AnnotationControllerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for AnnotationControllerSynchronousProxy {
    type Proxy = AnnotationControllerProxy;
    type Protocol = AnnotationControllerMarker;

    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 AnnotationControllerSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <AnnotationControllerMarker 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<AnnotationControllerEvent, fidl::Error> {
        AnnotationControllerEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Adds, updates, and removes annotations.
    ///
    /// The server is expected to adhere to the following conventions:
    ///
    /// * If a key in `annotations_to_set` is new, a new annotation is added
    /// * If a key in `annotations_to_set` already exists, the annotation value is updated
    /// * If a key in `annotations_to_delete` does not exist, it is ignored
    ///
    /// The same key cannot appear twice in a call to UpdateAnnotations().  In other words,
    /// to set two Annotations with matching keys is illegal, as is an attempt to set an
    /// Annotation and also delete it.
    ///
    /// If the operation results in an error, the annotations remain unchanged,
    /// and will not be partially updated.
    ///
    /// * error `UpdateAnnotationsError.INVALID_ARGS` if the same key exists in
    ///   both `annotations_to_set` and `annotations_to_delete`.
    /// * error `UpdateAnnotationsError.INVALID_ARGS` if a key in `annotations_to_set` or
    ///   `annotations_to_delete` has an empty namespace.
    /// * error `UpdateAnnotationsError.INVALID_ARGS` if an `AnnotationValue.buffer` in
    ///   `annotations_to_set` could not be read.
    /// * error `UpdateAnnotationsError.TOO_MANY_ANNOTATIONS` if the operation results
    ///   in more than `MAX_ANNOTATIONS_PER_ELEMENT` annotations existing.
    pub fn r#update_annotations(
        &self,
        mut annotations_to_set: Vec<Annotation>,
        mut annotations_to_delete: &[AnnotationKey],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<AnnotationControllerUpdateAnnotationsResult, fidl::Error> {
        let _response = self.client.send_query::<
            AnnotationControllerUpdateAnnotationsRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, UpdateAnnotationsError>,
        >(
            (annotations_to_set.as_mut(), annotations_to_delete,),
            0x5718e51a2774c686,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Returns the current `Annotations` for the element.
    ///
    /// * error `GetAnnotationsError` if the annotations could not be returned.
    pub fn r#get_annotations(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<AnnotationControllerGetAnnotationsResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                AnnotationControllerGetAnnotationsResponse,
                GetAnnotationsError,
            >>(
                (), 0xae78b17381824fa, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.annotations))
    }

    /// Returns the full set of `Annotations` when one or more of them have changed, or
    /// when this method is called by the client for the first time.
    ///
    /// This operation does not block other requests from the client, but only one
    /// `WatchAnnotations` request at a time can be made on a connection. If the
    /// client makes a second `WatchAnnotations` request before waiting for the
    /// previous request to complete, the connection will be closed.
    ///
    /// * error `WatchAnnotationsError` if the annotations could not be returned.
    pub fn r#watch_annotations(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<AnnotationControllerWatchAnnotationsResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                AnnotationControllerWatchAnnotationsResponse,
                WatchAnnotationsError,
            >>(
                (), 0x253b196cae31356f, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.annotations))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for AnnotationControllerProxy {
    type Protocol = AnnotationControllerMarker;

    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 AnnotationControllerProxy {
    /// Create a new Proxy for fuchsia.element/AnnotationController.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <AnnotationControllerMarker 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) -> AnnotationControllerEventStream {
        AnnotationControllerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Adds, updates, and removes annotations.
    ///
    /// The server is expected to adhere to the following conventions:
    ///
    /// * If a key in `annotations_to_set` is new, a new annotation is added
    /// * If a key in `annotations_to_set` already exists, the annotation value is updated
    /// * If a key in `annotations_to_delete` does not exist, it is ignored
    ///
    /// The same key cannot appear twice in a call to UpdateAnnotations().  In other words,
    /// to set two Annotations with matching keys is illegal, as is an attempt to set an
    /// Annotation and also delete it.
    ///
    /// If the operation results in an error, the annotations remain unchanged,
    /// and will not be partially updated.
    ///
    /// * error `UpdateAnnotationsError.INVALID_ARGS` if the same key exists in
    ///   both `annotations_to_set` and `annotations_to_delete`.
    /// * error `UpdateAnnotationsError.INVALID_ARGS` if a key in `annotations_to_set` or
    ///   `annotations_to_delete` has an empty namespace.
    /// * error `UpdateAnnotationsError.INVALID_ARGS` if an `AnnotationValue.buffer` in
    ///   `annotations_to_set` could not be read.
    /// * error `UpdateAnnotationsError.TOO_MANY_ANNOTATIONS` if the operation results
    ///   in more than `MAX_ANNOTATIONS_PER_ELEMENT` annotations existing.
    pub fn r#update_annotations(
        &self,
        mut annotations_to_set: Vec<Annotation>,
        mut annotations_to_delete: &[AnnotationKey],
    ) -> fidl::client::QueryResponseFut<
        AnnotationControllerUpdateAnnotationsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        AnnotationControllerProxyInterface::r#update_annotations(
            self,
            annotations_to_set,
            annotations_to_delete,
        )
    }

    /// Returns the current `Annotations` for the element.
    ///
    /// * error `GetAnnotationsError` if the annotations could not be returned.
    pub fn r#get_annotations(
        &self,
    ) -> fidl::client::QueryResponseFut<
        AnnotationControllerGetAnnotationsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        AnnotationControllerProxyInterface::r#get_annotations(self)
    }

    /// Returns the full set of `Annotations` when one or more of them have changed, or
    /// when this method is called by the client for the first time.
    ///
    /// This operation does not block other requests from the client, but only one
    /// `WatchAnnotations` request at a time can be made on a connection. If the
    /// client makes a second `WatchAnnotations` request before waiting for the
    /// previous request to complete, the connection will be closed.
    ///
    /// * error `WatchAnnotationsError` if the annotations could not be returned.
    pub fn r#watch_annotations(
        &self,
    ) -> fidl::client::QueryResponseFut<
        AnnotationControllerWatchAnnotationsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        AnnotationControllerProxyInterface::r#watch_annotations(self)
    }
}

impl AnnotationControllerProxyInterface for AnnotationControllerProxy {
    type UpdateAnnotationsResponseFut = fidl::client::QueryResponseFut<
        AnnotationControllerUpdateAnnotationsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#update_annotations(
        &self,
        mut annotations_to_set: Vec<Annotation>,
        mut annotations_to_delete: &[AnnotationKey],
    ) -> Self::UpdateAnnotationsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<AnnotationControllerUpdateAnnotationsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, UpdateAnnotationsError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5718e51a2774c686,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            AnnotationControllerUpdateAnnotationsRequest,
            AnnotationControllerUpdateAnnotationsResult,
        >(
            (annotations_to_set.as_mut(), annotations_to_delete,),
            0x5718e51a2774c686,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetAnnotationsResponseFut = fidl::client::QueryResponseFut<
        AnnotationControllerGetAnnotationsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_annotations(&self) -> Self::GetAnnotationsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<AnnotationControllerGetAnnotationsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    AnnotationControllerGetAnnotationsResponse,
                    GetAnnotationsError,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xae78b17381824fa,
            >(_buf?)?;
            Ok(_response.map(|x| x.annotations))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            AnnotationControllerGetAnnotationsResult,
        >(
            (),
            0xae78b17381824fa,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type WatchAnnotationsResponseFut = fidl::client::QueryResponseFut<
        AnnotationControllerWatchAnnotationsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#watch_annotations(&self) -> Self::WatchAnnotationsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<AnnotationControllerWatchAnnotationsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    AnnotationControllerWatchAnnotationsResponse,
                    WatchAnnotationsError,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x253b196cae31356f,
            >(_buf?)?;
            Ok(_response.map(|x| x.annotations))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            AnnotationControllerWatchAnnotationsResult,
        >(
            (),
            0x253b196cae31356f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for AnnotationControllerRequestStream {
    type Protocol = AnnotationControllerMarker;
    type ControlHandle = AnnotationControllerControlHandle;

    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 {
        AnnotationControllerControlHandle { 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 AnnotationControllerRequestStream {
    type Item = Result<AnnotationControllerRequest, 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 AnnotationControllerRequestStream 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 {
                0x5718e51a2774c686 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(AnnotationControllerUpdateAnnotationsRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AnnotationControllerUpdateAnnotationsRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = AnnotationControllerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(AnnotationControllerRequest::UpdateAnnotations {annotations_to_set: req.annotations_to_set,
annotations_to_delete: req.annotations_to_delete,

                        responder: AnnotationControllerUpdateAnnotationsResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0xae78b17381824fa => {
                    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 = AnnotationControllerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(AnnotationControllerRequest::GetAnnotations {
                        responder: AnnotationControllerGetAnnotationsResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x253b196cae31356f => {
                    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 = AnnotationControllerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(AnnotationControllerRequest::WatchAnnotations {
                        responder: AnnotationControllerWatchAnnotationsResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <AnnotationControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// An interface to create, read, update, and delete annotations,
/// typically on an element or its view.
#[derive(Debug)]
pub enum AnnotationControllerRequest {
    /// Adds, updates, and removes annotations.
    ///
    /// The server is expected to adhere to the following conventions:
    ///
    /// * If a key in `annotations_to_set` is new, a new annotation is added
    /// * If a key in `annotations_to_set` already exists, the annotation value is updated
    /// * If a key in `annotations_to_delete` does not exist, it is ignored
    ///
    /// The same key cannot appear twice in a call to UpdateAnnotations().  In other words,
    /// to set two Annotations with matching keys is illegal, as is an attempt to set an
    /// Annotation and also delete it.
    ///
    /// If the operation results in an error, the annotations remain unchanged,
    /// and will not be partially updated.
    ///
    /// * error `UpdateAnnotationsError.INVALID_ARGS` if the same key exists in
    ///   both `annotations_to_set` and `annotations_to_delete`.
    /// * error `UpdateAnnotationsError.INVALID_ARGS` if a key in `annotations_to_set` or
    ///   `annotations_to_delete` has an empty namespace.
    /// * error `UpdateAnnotationsError.INVALID_ARGS` if an `AnnotationValue.buffer` in
    ///   `annotations_to_set` could not be read.
    /// * error `UpdateAnnotationsError.TOO_MANY_ANNOTATIONS` if the operation results
    ///   in more than `MAX_ANNOTATIONS_PER_ELEMENT` annotations existing.
    UpdateAnnotations {
        annotations_to_set: Vec<Annotation>,
        annotations_to_delete: Vec<AnnotationKey>,
        responder: AnnotationControllerUpdateAnnotationsResponder,
    },
    /// Returns the current `Annotations` for the element.
    ///
    /// * error `GetAnnotationsError` if the annotations could not be returned.
    GetAnnotations { responder: AnnotationControllerGetAnnotationsResponder },
    /// Returns the full set of `Annotations` when one or more of them have changed, or
    /// when this method is called by the client for the first time.
    ///
    /// This operation does not block other requests from the client, but only one
    /// `WatchAnnotations` request at a time can be made on a connection. If the
    /// client makes a second `WatchAnnotations` request before waiting for the
    /// previous request to complete, the connection will be closed.
    ///
    /// * error `WatchAnnotationsError` if the annotations could not be returned.
    WatchAnnotations { responder: AnnotationControllerWatchAnnotationsResponder },
}

impl AnnotationControllerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_update_annotations(
        self,
    ) -> Option<(Vec<Annotation>, Vec<AnnotationKey>, AnnotationControllerUpdateAnnotationsResponder)>
    {
        if let AnnotationControllerRequest::UpdateAnnotations {
            annotations_to_set,
            annotations_to_delete,
            responder,
        } = self
        {
            Some((annotations_to_set, annotations_to_delete, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_annotations(self) -> Option<(AnnotationControllerGetAnnotationsResponder)> {
        if let AnnotationControllerRequest::GetAnnotations { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_watch_annotations(self) -> Option<(AnnotationControllerWatchAnnotationsResponder)> {
        if let AnnotationControllerRequest::WatchAnnotations { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            AnnotationControllerRequest::UpdateAnnotations { .. } => "update_annotations",
            AnnotationControllerRequest::GetAnnotations { .. } => "get_annotations",
            AnnotationControllerRequest::WatchAnnotations { .. } => "watch_annotations",
        }
    }
}

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

impl fidl::endpoints::ControlHandle for AnnotationControllerControlHandle {
    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 AnnotationControllerControlHandle {}

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

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

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

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

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

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

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

    fn send_raw(
        &self,
        mut result: Result<Vec<Annotation>, GetAnnotationsError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            AnnotationControllerGetAnnotationsResponse,
            GetAnnotationsError,
        >>(
            result.as_mut().map_err(|e| *e).map(|annotations| (annotations.as_mut_slice(),)),
            self.tx_id,
            0xae78b17381824fa,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(
        &self,
        mut result: Result<Vec<Annotation>, WatchAnnotationsError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            AnnotationControllerWatchAnnotationsResponse,
            WatchAnnotationsError,
        >>(
            result.as_mut().map_err(|e| *e).map(|annotations| (annotations.as_mut_slice(),)),
            self.tx_id,
            0x253b196cae31356f,
            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 trait ControllerProxyInterface: Send + Sync {
    type UpdateAnnotationsResponseFut: std::future::Future<
            Output = Result<AnnotationControllerUpdateAnnotationsResult, fidl::Error>,
        > + Send;
    fn r#update_annotations(
        &self,
        annotations_to_set: Vec<Annotation>,
        annotations_to_delete: &[AnnotationKey],
    ) -> Self::UpdateAnnotationsResponseFut;
    type GetAnnotationsResponseFut: std::future::Future<Output = Result<AnnotationControllerGetAnnotationsResult, fidl::Error>>
        + Send;
    fn r#get_annotations(&self) -> Self::GetAnnotationsResponseFut;
    type WatchAnnotationsResponseFut: std::future::Future<
            Output = Result<AnnotationControllerWatchAnnotationsResult, fidl::Error>,
        > + Send;
    fn r#watch_annotations(&self) -> Self::WatchAnnotationsResponseFut;
}
#[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)?)
    }

    /// Adds, updates, and removes annotations.
    ///
    /// The server is expected to adhere to the following conventions:
    ///
    /// * If a key in `annotations_to_set` is new, a new annotation is added
    /// * If a key in `annotations_to_set` already exists, the annotation value is updated
    /// * If a key in `annotations_to_delete` does not exist, it is ignored
    ///
    /// The same key cannot appear twice in a call to UpdateAnnotations().  In other words,
    /// to set two Annotations with matching keys is illegal, as is an attempt to set an
    /// Annotation and also delete it.
    ///
    /// If the operation results in an error, the annotations remain unchanged,
    /// and will not be partially updated.
    ///
    /// * error `UpdateAnnotationsError.INVALID_ARGS` if the same key exists in
    ///   both `annotations_to_set` and `annotations_to_delete`.
    /// * error `UpdateAnnotationsError.INVALID_ARGS` if a key in `annotations_to_set` or
    ///   `annotations_to_delete` has an empty namespace.
    /// * error `UpdateAnnotationsError.INVALID_ARGS` if an `AnnotationValue.buffer` in
    ///   `annotations_to_set` could not be read.
    /// * error `UpdateAnnotationsError.TOO_MANY_ANNOTATIONS` if the operation results
    ///   in more than `MAX_ANNOTATIONS_PER_ELEMENT` annotations existing.
    pub fn r#update_annotations(
        &self,
        mut annotations_to_set: Vec<Annotation>,
        mut annotations_to_delete: &[AnnotationKey],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<AnnotationControllerUpdateAnnotationsResult, fidl::Error> {
        let _response = self.client.send_query::<
            AnnotationControllerUpdateAnnotationsRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, UpdateAnnotationsError>,
        >(
            (annotations_to_set.as_mut(), annotations_to_delete,),
            0x5718e51a2774c686,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Returns the current `Annotations` for the element.
    ///
    /// * error `GetAnnotationsError` if the annotations could not be returned.
    pub fn r#get_annotations(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<AnnotationControllerGetAnnotationsResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                AnnotationControllerGetAnnotationsResponse,
                GetAnnotationsError,
            >>(
                (), 0xae78b17381824fa, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.annotations))
    }

    /// Returns the full set of `Annotations` when one or more of them have changed, or
    /// when this method is called by the client for the first time.
    ///
    /// This operation does not block other requests from the client, but only one
    /// `WatchAnnotations` request at a time can be made on a connection. If the
    /// client makes a second `WatchAnnotations` request before waiting for the
    /// previous request to complete, the connection will be closed.
    ///
    /// * error `WatchAnnotationsError` if the annotations could not be returned.
    pub fn r#watch_annotations(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<AnnotationControllerWatchAnnotationsResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                AnnotationControllerWatchAnnotationsResponse,
                WatchAnnotationsError,
            >>(
                (), 0x253b196cae31356f, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.annotations))
    }
}

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

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

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

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

#[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.element/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() }
    }

    /// Adds, updates, and removes annotations.
    ///
    /// The server is expected to adhere to the following conventions:
    ///
    /// * If a key in `annotations_to_set` is new, a new annotation is added
    /// * If a key in `annotations_to_set` already exists, the annotation value is updated
    /// * If a key in `annotations_to_delete` does not exist, it is ignored
    ///
    /// The same key cannot appear twice in a call to UpdateAnnotations().  In other words,
    /// to set two Annotations with matching keys is illegal, as is an attempt to set an
    /// Annotation and also delete it.
    ///
    /// If the operation results in an error, the annotations remain unchanged,
    /// and will not be partially updated.
    ///
    /// * error `UpdateAnnotationsError.INVALID_ARGS` if the same key exists in
    ///   both `annotations_to_set` and `annotations_to_delete`.
    /// * error `UpdateAnnotationsError.INVALID_ARGS` if a key in `annotations_to_set` or
    ///   `annotations_to_delete` has an empty namespace.
    /// * error `UpdateAnnotationsError.INVALID_ARGS` if an `AnnotationValue.buffer` in
    ///   `annotations_to_set` could not be read.
    /// * error `UpdateAnnotationsError.TOO_MANY_ANNOTATIONS` if the operation results
    ///   in more than `MAX_ANNOTATIONS_PER_ELEMENT` annotations existing.
    pub fn r#update_annotations(
        &self,
        mut annotations_to_set: Vec<Annotation>,
        mut annotations_to_delete: &[AnnotationKey],
    ) -> fidl::client::QueryResponseFut<
        AnnotationControllerUpdateAnnotationsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ControllerProxyInterface::r#update_annotations(
            self,
            annotations_to_set,
            annotations_to_delete,
        )
    }

    /// Returns the current `Annotations` for the element.
    ///
    /// * error `GetAnnotationsError` if the annotations could not be returned.
    pub fn r#get_annotations(
        &self,
    ) -> fidl::client::QueryResponseFut<
        AnnotationControllerGetAnnotationsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ControllerProxyInterface::r#get_annotations(self)
    }

    /// Returns the full set of `Annotations` when one or more of them have changed, or
    /// when this method is called by the client for the first time.
    ///
    /// This operation does not block other requests from the client, but only one
    /// `WatchAnnotations` request at a time can be made on a connection. If the
    /// client makes a second `WatchAnnotations` request before waiting for the
    /// previous request to complete, the connection will be closed.
    ///
    /// * error `WatchAnnotationsError` if the annotations could not be returned.
    pub fn r#watch_annotations(
        &self,
    ) -> fidl::client::QueryResponseFut<
        AnnotationControllerWatchAnnotationsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ControllerProxyInterface::r#watch_annotations(self)
    }
}

impl ControllerProxyInterface for ControllerProxy {
    type UpdateAnnotationsResponseFut = fidl::client::QueryResponseFut<
        AnnotationControllerUpdateAnnotationsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#update_annotations(
        &self,
        mut annotations_to_set: Vec<Annotation>,
        mut annotations_to_delete: &[AnnotationKey],
    ) -> Self::UpdateAnnotationsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<AnnotationControllerUpdateAnnotationsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, UpdateAnnotationsError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5718e51a2774c686,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            AnnotationControllerUpdateAnnotationsRequest,
            AnnotationControllerUpdateAnnotationsResult,
        >(
            (annotations_to_set.as_mut(), annotations_to_delete,),
            0x5718e51a2774c686,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetAnnotationsResponseFut = fidl::client::QueryResponseFut<
        AnnotationControllerGetAnnotationsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_annotations(&self) -> Self::GetAnnotationsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<AnnotationControllerGetAnnotationsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    AnnotationControllerGetAnnotationsResponse,
                    GetAnnotationsError,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xae78b17381824fa,
            >(_buf?)?;
            Ok(_response.map(|x| x.annotations))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            AnnotationControllerGetAnnotationsResult,
        >(
            (),
            0xae78b17381824fa,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type WatchAnnotationsResponseFut = fidl::client::QueryResponseFut<
        AnnotationControllerWatchAnnotationsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#watch_annotations(&self) -> Self::WatchAnnotationsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<AnnotationControllerWatchAnnotationsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    AnnotationControllerWatchAnnotationsResponse,
                    WatchAnnotationsError,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x253b196cae31356f,
            >(_buf?)?;
            Ok(_response.map(|x| x.annotations))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            AnnotationControllerWatchAnnotationsResult,
        >(
            (),
            0x253b196cae31356f,
            fidl::encoding::DynamicFlags::empty(),
            _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 {}

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 {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <ControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.element/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 {
                    0x5718e51a2774c686 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            AnnotationControllerUpdateAnnotationsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AnnotationControllerUpdateAnnotationsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ControllerControlHandle { inner: this.inner.clone() };
                        Ok(ControllerRequest::UpdateAnnotations {
                            annotations_to_set: req.annotations_to_set,
                            annotations_to_delete: req.annotations_to_delete,

                            responder: ControllerUpdateAnnotationsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0xae78b17381824fa => {
                        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::GetAnnotations {
                            responder: ControllerGetAnnotationsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x253b196cae31356f => {
                        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::WatchAnnotations {
                            responder: ControllerWatchAnnotationsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <ControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// An interface that gives clients of `Manager` (element proposers) control
/// over the proposed element's lifecycle and annotations.
///
/// ## Lifecycle
///
/// The client must keep `Controller` connected to ensure the element
/// remains in the session and is not destroyed. Once `Controller` is closed,
/// the element and its component will be terminated. The element may also terminate
/// itself, which will cause `Controller` to close.
#[derive(Debug)]
pub enum ControllerRequest {
    /// Adds, updates, and removes annotations.
    ///
    /// The server is expected to adhere to the following conventions:
    ///
    /// * If a key in `annotations_to_set` is new, a new annotation is added
    /// * If a key in `annotations_to_set` already exists, the annotation value is updated
    /// * If a key in `annotations_to_delete` does not exist, it is ignored
    ///
    /// The same key cannot appear twice in a call to UpdateAnnotations().  In other words,
    /// to set two Annotations with matching keys is illegal, as is an attempt to set an
    /// Annotation and also delete it.
    ///
    /// If the operation results in an error, the annotations remain unchanged,
    /// and will not be partially updated.
    ///
    /// * error `UpdateAnnotationsError.INVALID_ARGS` if the same key exists in
    ///   both `annotations_to_set` and `annotations_to_delete`.
    /// * error `UpdateAnnotationsError.INVALID_ARGS` if a key in `annotations_to_set` or
    ///   `annotations_to_delete` has an empty namespace.
    /// * error `UpdateAnnotationsError.INVALID_ARGS` if an `AnnotationValue.buffer` in
    ///   `annotations_to_set` could not be read.
    /// * error `UpdateAnnotationsError.TOO_MANY_ANNOTATIONS` if the operation results
    ///   in more than `MAX_ANNOTATIONS_PER_ELEMENT` annotations existing.
    UpdateAnnotations {
        annotations_to_set: Vec<Annotation>,
        annotations_to_delete: Vec<AnnotationKey>,
        responder: ControllerUpdateAnnotationsResponder,
    },
    /// Returns the current `Annotations` for the element.
    ///
    /// * error `GetAnnotationsError` if the annotations could not be returned.
    GetAnnotations { responder: ControllerGetAnnotationsResponder },
    /// Returns the full set of `Annotations` when one or more of them have changed, or
    /// when this method is called by the client for the first time.
    ///
    /// This operation does not block other requests from the client, but only one
    /// `WatchAnnotations` request at a time can be made on a connection. If the
    /// client makes a second `WatchAnnotations` request before waiting for the
    /// previous request to complete, the connection will be closed.
    ///
    /// * error `WatchAnnotationsError` if the annotations could not be returned.
    WatchAnnotations { responder: ControllerWatchAnnotationsResponder },
}

impl ControllerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_update_annotations(
        self,
    ) -> Option<(Vec<Annotation>, Vec<AnnotationKey>, ControllerUpdateAnnotationsResponder)> {
        if let ControllerRequest::UpdateAnnotations {
            annotations_to_set,
            annotations_to_delete,
            responder,
        } = self
        {
            Some((annotations_to_set, annotations_to_delete, responder))
        } else {
            None
        }
    }

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

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

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            ControllerRequest::UpdateAnnotations { .. } => "update_annotations",
            ControllerRequest::GetAnnotations { .. } => "get_annotations",
            ControllerRequest::WatchAnnotations { .. } => "watch_annotations",
        }
    }
}

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

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

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct ControllerGetAnnotationsResponder {
    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 ControllerGetAnnotationsResponder {
    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 ControllerGetAnnotationsResponder {
    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 ControllerGetAnnotationsResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<Vec<Annotation>, GetAnnotationsError>,
    ) -> 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<Annotation>, GetAnnotationsError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<Vec<Annotation>, GetAnnotationsError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            AnnotationControllerGetAnnotationsResponse,
            GetAnnotationsError,
        >>(
            result.as_mut().map_err(|e| *e).map(|annotations| (annotations.as_mut_slice(),)),
            self.tx_id,
            0xae78b17381824fa,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct ControllerWatchAnnotationsResponder {
    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 ControllerWatchAnnotationsResponder {
    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 ControllerWatchAnnotationsResponder {
    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 ControllerWatchAnnotationsResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<Vec<Annotation>, WatchAnnotationsError>,
    ) -> 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<Annotation>, WatchAnnotationsError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<Vec<Annotation>, WatchAnnotationsError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            AnnotationControllerWatchAnnotationsResponse,
            WatchAnnotationsError,
        >>(
            result.as_mut().map_err(|e| *e).map(|annotations| (annotations.as_mut_slice(),)),
            self.tx_id,
            0x253b196cae31356f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for GraphicalPresenterMarker {
    type Proxy = GraphicalPresenterProxy;
    type RequestStream = GraphicalPresenterRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = GraphicalPresenterSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.element.GraphicalPresenter";
}
impl fidl::endpoints::DiscoverableProtocolMarker for GraphicalPresenterMarker {}
pub type GraphicalPresenterPresentViewResult = Result<(), PresentViewError>;

pub trait GraphicalPresenterProxyInterface: Send + Sync {
    type PresentViewResponseFut: std::future::Future<Output = Result<GraphicalPresenterPresentViewResult, fidl::Error>>
        + Send;
    fn r#present_view(
        &self,
        view_spec: ViewSpec,
        annotation_controller: Option<fidl::endpoints::ClientEnd<AnnotationControllerMarker>>,
        view_controller_request: Option<fidl::endpoints::ServerEnd<ViewControllerMarker>>,
    ) -> Self::PresentViewResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct GraphicalPresenterSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for GraphicalPresenterSynchronousProxy {
    type Proxy = GraphicalPresenterProxy;
    type Protocol = GraphicalPresenterMarker;

    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 GraphicalPresenterSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <GraphicalPresenterMarker 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<GraphicalPresenterEvent, fidl::Error> {
        GraphicalPresenterEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Presents the view described by `view_spec`.
    ///
    /// If `view_controller_request` is provided, it will be connected to a `ViewController`
    /// implemented by the `GraphicalPresenter` server. When the view is dismissed,
    /// the `ViewController` channel is closed with a `ZX_OK`, at which point it is safe
    /// to clean up resources backing the view. To dismiss the view, the client should
    /// call `ViewController.Dismiss()` and wait for the `ZX_OK` epitaph.
    /// Not providing a `view_controller_request` handle will make it impossible for the
    /// client to observe the view's lifecycle.
    ///
    /// + `view_spec` describes the view to present
    /// + `annotation_controller` a handle to an `AnnotationController`, allowing the
    ///    `GraphicalPresenter` server to observe and update the view's annotations.
    /// + `view_controller_request` an optional request for a controller for the view
    /// * error `view_spec`  must contain `view_holder_token` and `view_ref` for Gfx views,
    ///   OR `viewport_creation_token` for Flatland views, but never both. If both are
    ///   set, error `PresentViewError.INVALID_ARGS` is returned.
    /// * error `PresentViewError.INVALID_ARGS` if `spec.view_holder_token` or
    ///   `spec.view_ref` are missing or invalid.
    pub fn r#present_view(
        &self,
        mut view_spec: ViewSpec,
        mut annotation_controller: Option<fidl::endpoints::ClientEnd<AnnotationControllerMarker>>,
        mut view_controller_request: Option<fidl::endpoints::ServerEnd<ViewControllerMarker>>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<GraphicalPresenterPresentViewResult, fidl::Error> {
        let _response = self.client.send_query::<
            GraphicalPresenterPresentViewRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, PresentViewError>,
        >(
            (&mut view_spec, annotation_controller, view_controller_request,),
            0x396042dd1422ac7a,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for GraphicalPresenterProxy {
    type Protocol = GraphicalPresenterMarker;

    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 GraphicalPresenterProxy {
    /// Create a new Proxy for fuchsia.element/GraphicalPresenter.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <GraphicalPresenterMarker 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) -> GraphicalPresenterEventStream {
        GraphicalPresenterEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Presents the view described by `view_spec`.
    ///
    /// If `view_controller_request` is provided, it will be connected to a `ViewController`
    /// implemented by the `GraphicalPresenter` server. When the view is dismissed,
    /// the `ViewController` channel is closed with a `ZX_OK`, at which point it is safe
    /// to clean up resources backing the view. To dismiss the view, the client should
    /// call `ViewController.Dismiss()` and wait for the `ZX_OK` epitaph.
    /// Not providing a `view_controller_request` handle will make it impossible for the
    /// client to observe the view's lifecycle.
    ///
    /// + `view_spec` describes the view to present
    /// + `annotation_controller` a handle to an `AnnotationController`, allowing the
    ///    `GraphicalPresenter` server to observe and update the view's annotations.
    /// + `view_controller_request` an optional request for a controller for the view
    /// * error `view_spec`  must contain `view_holder_token` and `view_ref` for Gfx views,
    ///   OR `viewport_creation_token` for Flatland views, but never both. If both are
    ///   set, error `PresentViewError.INVALID_ARGS` is returned.
    /// * error `PresentViewError.INVALID_ARGS` if `spec.view_holder_token` or
    ///   `spec.view_ref` are missing or invalid.
    pub fn r#present_view(
        &self,
        mut view_spec: ViewSpec,
        mut annotation_controller: Option<fidl::endpoints::ClientEnd<AnnotationControllerMarker>>,
        mut view_controller_request: Option<fidl::endpoints::ServerEnd<ViewControllerMarker>>,
    ) -> fidl::client::QueryResponseFut<
        GraphicalPresenterPresentViewResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        GraphicalPresenterProxyInterface::r#present_view(
            self,
            view_spec,
            annotation_controller,
            view_controller_request,
        )
    }
}

impl GraphicalPresenterProxyInterface for GraphicalPresenterProxy {
    type PresentViewResponseFut = fidl::client::QueryResponseFut<
        GraphicalPresenterPresentViewResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#present_view(
        &self,
        mut view_spec: ViewSpec,
        mut annotation_controller: Option<fidl::endpoints::ClientEnd<AnnotationControllerMarker>>,
        mut view_controller_request: Option<fidl::endpoints::ServerEnd<ViewControllerMarker>>,
    ) -> Self::PresentViewResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<GraphicalPresenterPresentViewResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, PresentViewError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x396042dd1422ac7a,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            GraphicalPresenterPresentViewRequest,
            GraphicalPresenterPresentViewResult,
        >(
            (&mut view_spec, annotation_controller, view_controller_request,),
            0x396042dd1422ac7a,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for GraphicalPresenterRequestStream {
    type Protocol = GraphicalPresenterMarker;
    type ControlHandle = GraphicalPresenterControlHandle;

    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 {
        GraphicalPresenterControlHandle { 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 GraphicalPresenterRequestStream {
    type Item = Result<GraphicalPresenterRequest, 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 GraphicalPresenterRequestStream 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 {
                0x396042dd1422ac7a => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(GraphicalPresenterPresentViewRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<GraphicalPresenterPresentViewRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = GraphicalPresenterControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(GraphicalPresenterRequest::PresentView {view_spec: req.view_spec,
annotation_controller: req.annotation_controller,
view_controller_request: req.view_controller_request,

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

/// An interface used to instruct a server to present graphical views, and observe
/// and control the view's lifecycle.
#[derive(Debug)]
pub enum GraphicalPresenterRequest {
    /// Presents the view described by `view_spec`.
    ///
    /// If `view_controller_request` is provided, it will be connected to a `ViewController`
    /// implemented by the `GraphicalPresenter` server. When the view is dismissed,
    /// the `ViewController` channel is closed with a `ZX_OK`, at which point it is safe
    /// to clean up resources backing the view. To dismiss the view, the client should
    /// call `ViewController.Dismiss()` and wait for the `ZX_OK` epitaph.
    /// Not providing a `view_controller_request` handle will make it impossible for the
    /// client to observe the view's lifecycle.
    ///
    /// + `view_spec` describes the view to present
    /// + `annotation_controller` a handle to an `AnnotationController`, allowing the
    ///    `GraphicalPresenter` server to observe and update the view's annotations.
    /// + `view_controller_request` an optional request for a controller for the view
    /// * error `view_spec`  must contain `view_holder_token` and `view_ref` for Gfx views,
    ///   OR `viewport_creation_token` for Flatland views, but never both. If both are
    ///   set, error `PresentViewError.INVALID_ARGS` is returned.
    /// * error `PresentViewError.INVALID_ARGS` if `spec.view_holder_token` or
    ///   `spec.view_ref` are missing or invalid.
    PresentView {
        view_spec: ViewSpec,
        annotation_controller: Option<fidl::endpoints::ClientEnd<AnnotationControllerMarker>>,
        view_controller_request: Option<fidl::endpoints::ServerEnd<ViewControllerMarker>>,
        responder: GraphicalPresenterPresentViewResponder,
    },
}

impl GraphicalPresenterRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_present_view(
        self,
    ) -> Option<(
        ViewSpec,
        Option<fidl::endpoints::ClientEnd<AnnotationControllerMarker>>,
        Option<fidl::endpoints::ServerEnd<ViewControllerMarker>>,
        GraphicalPresenterPresentViewResponder,
    )> {
        if let GraphicalPresenterRequest::PresentView {
            view_spec,
            annotation_controller,
            view_controller_request,
            responder,
        } = self
        {
            Some((view_spec, annotation_controller, view_controller_request, responder))
        } else {
            None
        }
    }

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

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

impl fidl::endpoints::ControlHandle for GraphicalPresenterControlHandle {
    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 GraphicalPresenterControlHandle {}

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for ManagerMarker {
    type Proxy = ManagerProxy;
    type RequestStream = ManagerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ManagerSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.element.Manager";
}
impl fidl::endpoints::DiscoverableProtocolMarker for ManagerMarker {}
pub type ManagerProposeElementResult = Result<(), ManagerError>;
pub type ManagerRemoveElementResult = Result<(), ManagerError>;

pub trait ManagerProxyInterface: Send + Sync {
    type ProposeElementResponseFut: std::future::Future<Output = Result<ManagerProposeElementResult, fidl::Error>>
        + Send;
    fn r#propose_element(
        &self,
        spec: Spec,
        controller: Option<fidl::endpoints::ServerEnd<ControllerMarker>>,
    ) -> Self::ProposeElementResponseFut;
    type RemoveElementResponseFut: std::future::Future<Output = Result<ManagerRemoveElementResult, fidl::Error>>
        + Send;
    fn r#remove_element(&self, name: &str) -> Self::RemoveElementResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ManagerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ManagerSynchronousProxy {
    type Proxy = ManagerProxy;
    type Protocol = ManagerMarker;

    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 ManagerSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <ManagerMarker 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<ManagerEvent, fidl::Error> {
        ManagerEvent::decode(self.client.wait_for_event(deadline)?)
    }

    pub fn r#propose_element(
        &self,
        mut spec: Spec,
        mut controller: Option<fidl::endpoints::ServerEnd<ControllerMarker>>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ManagerProposeElementResult, fidl::Error> {
        let _response = self.client.send_query::<
            ManagerProposeElementRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, ManagerError>,
        >(
            (&mut spec, controller,),
            0x2af76679cd73b902,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Removes the element identified by `name` from the session. If the element is a persistent
    /// element, it is removed permanently. Any persistent storage that the element might have used
    /// is left untouched.
    pub fn r#remove_element(
        &self,
        mut name: &str,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ManagerRemoveElementResult, fidl::Error> {
        let _response = self.client.send_query::<
            ManagerRemoveElementRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, ManagerError>,
        >(
            (name,),
            0x1e65d66515e64b52,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for ManagerProxy {
    type Protocol = ManagerMarker;

    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 ManagerProxy {
    /// Create a new Proxy for fuchsia.element/Manager.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <ManagerMarker 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) -> ManagerEventStream {
        ManagerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    pub fn r#propose_element(
        &self,
        mut spec: Spec,
        mut controller: Option<fidl::endpoints::ServerEnd<ControllerMarker>>,
    ) -> fidl::client::QueryResponseFut<
        ManagerProposeElementResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ManagerProxyInterface::r#propose_element(self, spec, controller)
    }

    /// Removes the element identified by `name` from the session. If the element is a persistent
    /// element, it is removed permanently. Any persistent storage that the element might have used
    /// is left untouched.
    pub fn r#remove_element(
        &self,
        mut name: &str,
    ) -> fidl::client::QueryResponseFut<
        ManagerRemoveElementResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ManagerProxyInterface::r#remove_element(self, name)
    }
}

impl ManagerProxyInterface for ManagerProxy {
    type ProposeElementResponseFut = fidl::client::QueryResponseFut<
        ManagerProposeElementResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#propose_element(
        &self,
        mut spec: Spec,
        mut controller: Option<fidl::endpoints::ServerEnd<ControllerMarker>>,
    ) -> Self::ProposeElementResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ManagerProposeElementResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, ManagerError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2af76679cd73b902,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<ManagerProposeElementRequest, ManagerProposeElementResult>(
                (&mut spec, controller),
                0x2af76679cd73b902,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for ManagerRequestStream {
    type Protocol = ManagerMarker;
    type ControlHandle = ManagerControlHandle;

    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 {
        ManagerControlHandle { 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 ManagerRequestStream {
    type Item = Result<ManagerRequest, 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 ManagerRequestStream 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 {
                    0x2af76679cd73b902 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ManagerProposeElementRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ManagerProposeElementRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ManagerControlHandle { inner: this.inner.clone() };
                        Ok(ManagerRequest::ProposeElement {
                            spec: req.spec,
                            controller: req.controller,

                            responder: ManagerProposeElementResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1e65d66515e64b52 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ManagerRemoveElementRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ManagerRemoveElementRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ManagerControlHandle { inner: this.inner.clone() };
                        Ok(ManagerRequest::RemoveElement {
                            name: req.name,

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

/// An interface used to add elements to a session.
///
/// An *element* is a component that is expected to be instantiated as a child
/// of the session and (optionally) to interact with the user in some way.
///
/// The session will typically implement `Manager` and route it where needed.
/// For tools like `ffx session add` to work, the session must expose `Manager`
/// to its parent.
///
/// For example, a component in the session may be a non-interactive application that
/// listens to the network for a command to display an element to the user.
/// When it receives the command, the component calls `ProposeElement()`.
#[derive(Debug)]
pub enum ManagerRequest {
    ProposeElement {
        spec: Spec,
        controller: Option<fidl::endpoints::ServerEnd<ControllerMarker>>,
        responder: ManagerProposeElementResponder,
    },
    /// Removes the element identified by `name` from the session. If the element is a persistent
    /// element, it is removed permanently. Any persistent storage that the element might have used
    /// is left untouched.
    RemoveElement { name: String, responder: ManagerRemoveElementResponder },
}

impl ManagerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_propose_element(
        self,
    ) -> Option<(
        Spec,
        Option<fidl::endpoints::ServerEnd<ControllerMarker>>,
        ManagerProposeElementResponder,
    )> {
        if let ManagerRequest::ProposeElement { spec, controller, responder } = self {
            Some((spec, controller, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_remove_element(self) -> Option<(String, ManagerRemoveElementResponder)> {
        if let ManagerRequest::RemoveElement { name, responder } = self {
            Some((name, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            ManagerRequest::ProposeElement { .. } => "propose_element",
            ManagerRequest::RemoveElement { .. } => "remove_element",
        }
    }
}

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

impl fidl::endpoints::ControlHandle for ManagerControlHandle {
    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 ManagerControlHandle {}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for ViewControllerMarker {
    type Proxy = ViewControllerProxy;
    type RequestStream = ViewControllerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ViewControllerSynchronousProxy;

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

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

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ViewControllerSynchronousProxy {
    type Proxy = ViewControllerProxy;
    type Protocol = ViewControllerMarker;

    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 ViewControllerSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <ViewControllerMarker 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<ViewControllerEvent, fidl::Error> {
        ViewControllerEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Instructs the presenter to dismiss the associated view. Once dismissed,
    /// the `ViewController` channel is closed with a `ZX_OK` epitaph. At this
    /// point, it is safe to clean up any resources (such as terminating
    /// a component) backing the view.
    ///
    /// Clients should call `Dismiss()` prior to closing the `ViewController`
    /// channel themselves.
    pub fn r#dismiss(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x794061fcab05a3dc,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for ViewControllerProxy {
    type Protocol = ViewControllerMarker;

    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 ViewControllerProxy {
    /// Create a new Proxy for fuchsia.element/ViewController.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <ViewControllerMarker 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) -> ViewControllerEventStream {
        ViewControllerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Instructs the presenter to dismiss the associated view. Once dismissed,
    /// the `ViewController` channel is closed with a `ZX_OK` epitaph. At this
    /// point, it is safe to clean up any resources (such as terminating
    /// a component) backing the view.
    ///
    /// Clients should call `Dismiss()` prior to closing the `ViewController`
    /// channel themselves.
    pub fn r#dismiss(&self) -> Result<(), fidl::Error> {
        ViewControllerProxyInterface::r#dismiss(self)
    }
}

impl ViewControllerProxyInterface for ViewControllerProxy {
    fn r#dismiss(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x794061fcab05a3dc,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

#[derive(Debug)]
pub enum ViewControllerEvent {
    OnPresented {},
}

impl ViewControllerEvent {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_presented(self) -> Option<()> {
        if let ViewControllerEvent::OnPresented {} = self {
            Some(())
        } else {
            None
        }
    }

    /// Decodes a message buffer as a [`ViewControllerEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<ViewControllerEvent, 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 {
            0x26977e68369330b5 => {
                let mut out = fidl::new_empty!(
                    fidl::encoding::EmptyPayload,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((ViewControllerEvent::OnPresented {}))
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name:
                    <ViewControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fidl::endpoints::RequestStream for ViewControllerRequestStream {
    type Protocol = ViewControllerMarker;
    type ControlHandle = ViewControllerControlHandle;

    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 {
        ViewControllerControlHandle { 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 ViewControllerRequestStream {
    type Item = Result<ViewControllerRequest, 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 ViewControllerRequestStream 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 {
                    0x794061fcab05a3dc => {
                        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 =
                            ViewControllerControlHandle { inner: this.inner.clone() };
                        Ok(ViewControllerRequest::Dismiss { control_handle })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <ViewControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Gives clients of `GraphicalPresenter` control over an individual view
/// presented through `PresentView()`.
#[derive(Debug)]
pub enum ViewControllerRequest {
    /// Instructs the presenter to dismiss the associated view. Once dismissed,
    /// the `ViewController` channel is closed with a `ZX_OK` epitaph. At this
    /// point, it is safe to clean up any resources (such as terminating
    /// a component) backing the view.
    ///
    /// Clients should call `Dismiss()` prior to closing the `ViewController`
    /// channel themselves.
    Dismiss { control_handle: ViewControllerControlHandle },
}

impl ViewControllerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_dismiss(self) -> Option<(ViewControllerControlHandle)> {
        if let ViewControllerRequest::Dismiss { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

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

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

impl fidl::endpoints::ControlHandle for ViewControllerControlHandle {
    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 ViewControllerControlHandle {
    pub fn send_on_presented(&self) -> Result<(), fidl::Error> {
        self.inner.send::<fidl::encoding::EmptyPayload>(
            (),
            0,
            0x26977e68369330b5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

mod internal {
    use super::*;

    impl fidl::encoding::ResourceTypeMarker for Annotation {
        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 Annotation {
        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<Annotation, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut Annotation
    {
        #[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::<Annotation>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<Annotation, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <AnnotationKey as fidl::encoding::ValueTypeMarker>::borrow(&self.key),
                    <AnnotationValue as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<AnnotationKey, fidl::encoding::DefaultFuchsiaResourceDialect>,
            T1: fidl::encoding::Encode<AnnotationValue, fidl::encoding::DefaultFuchsiaResourceDialect>,
        > fidl::encoding::Encode<Annotation, 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::<Annotation>(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 + 32, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for Annotation {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                key: fidl::new_empty!(AnnotationKey, fidl::encoding::DefaultFuchsiaResourceDialect),
                value: fidl::new_empty!(
                    AnnotationValue,
                    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!(
                AnnotationKey,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.key,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                AnnotationValue,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.value,
                decoder,
                offset + 32,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            AnnotationControllerUpdateAnnotationsRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut AnnotationControllerUpdateAnnotationsRequest
    {
        #[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::<AnnotationControllerUpdateAnnotationsRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<AnnotationControllerUpdateAnnotationsRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Vector<Annotation, 1024> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.annotations_to_set),
                    <fidl::encoding::Vector<AnnotationKey, 1024> as fidl::encoding::ValueTypeMarker>::borrow(&self.annotations_to_delete),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Vector<Annotation, 1024>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<
                fidl::encoding::Vector<AnnotationKey, 1024>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            AnnotationControllerUpdateAnnotationsRequest,
            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::<AnnotationControllerUpdateAnnotationsRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for AnnotationControllerUpdateAnnotationsRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                annotations_to_set: fidl::new_empty!(fidl::encoding::Vector<Annotation, 1024>, fidl::encoding::DefaultFuchsiaResourceDialect),
                annotations_to_delete: fidl::new_empty!(fidl::encoding::Vector<AnnotationKey, 1024>, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for AnnotationControllerGetAnnotationsResponse {
        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 AnnotationControllerGetAnnotationsResponse {
        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<
            AnnotationControllerGetAnnotationsResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut AnnotationControllerGetAnnotationsResponse
    {
        #[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::<AnnotationControllerGetAnnotationsResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<AnnotationControllerGetAnnotationsResponse, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Vector<Annotation, 1024> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.annotations),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Vector<Annotation, 1024>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            AnnotationControllerGetAnnotationsResponse,
            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::<AnnotationControllerGetAnnotationsResponse>(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 AnnotationControllerGetAnnotationsResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                annotations: fidl::new_empty!(fidl::encoding::Vector<Annotation, 1024>, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for AnnotationControllerWatchAnnotationsResponse {
        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 AnnotationControllerWatchAnnotationsResponse {
        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<
            AnnotationControllerWatchAnnotationsResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut AnnotationControllerWatchAnnotationsResponse
    {
        #[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::<AnnotationControllerWatchAnnotationsResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<AnnotationControllerWatchAnnotationsResponse, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Vector<Annotation, 1024> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.annotations),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Vector<Annotation, 1024>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            AnnotationControllerWatchAnnotationsResponse,
            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::<AnnotationControllerWatchAnnotationsResponse>(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 AnnotationControllerWatchAnnotationsResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                annotations: fidl::new_empty!(fidl::encoding::Vector<Annotation, 1024>, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for GraphicalPresenterPresentViewRequest {
        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 GraphicalPresenterPresentViewRequest {
        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<
            GraphicalPresenterPresentViewRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut GraphicalPresenterPresentViewRequest
    {
        #[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::<GraphicalPresenterPresentViewRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                GraphicalPresenterPresentViewRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <ViewSpec as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.view_spec,
                    ),
                    <fidl::encoding::Optional<
                        fidl::encoding::Endpoint<
                            fidl::endpoints::ClientEnd<AnnotationControllerMarker>,
                        >,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.annotation_controller,
                    ),
                    <fidl::encoding::Optional<
                        fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ViewControllerMarker>>,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.view_controller_request,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<ViewSpec, fidl::encoding::DefaultFuchsiaResourceDialect>,
            T1: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<AnnotationControllerMarker>,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T2: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ViewControllerMarker>>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            GraphicalPresenterPresentViewRequest,
            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::<GraphicalPresenterPresentViewRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            self.2.encode(encoder, offset + 20, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for GraphicalPresenterPresentViewRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                view_spec: fidl::new_empty!(
                    ViewSpec,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                annotation_controller: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::Endpoint<
                            fidl::endpoints::ClientEnd<AnnotationControllerMarker>,
                        >,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                view_controller_request: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ViewControllerMarker>>,
                    >,
                    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!(
                ViewSpec,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.view_spec,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<AnnotationControllerMarker>,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.annotation_controller,
                decoder,
                offset + 16,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ViewControllerMarker>>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.view_controller_request,
                decoder,
                offset + 20,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ManagerProposeElementRequest {
        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 ManagerProposeElementRequest {
        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<
            ManagerProposeElementRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ManagerProposeElementRequest
    {
        #[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::<ManagerProposeElementRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                ManagerProposeElementRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <Spec as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.spec),
                    <fidl::encoding::Optional<
                        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<Spec, fidl::encoding::DefaultFuchsiaResourceDialect>,
            T1: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ControllerMarker>>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            ManagerProposeElementRequest,
            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::<ManagerProposeElementRequest>(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 ManagerProposeElementRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                spec: fidl::new_empty!(Spec, fidl::encoding::DefaultFuchsiaResourceDialect),
                controller: fidl::new_empty!(
                    fidl::encoding::Optional<
                        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(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!(
                Spec,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.spec,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ControllerMarker>>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.controller,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

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

    impl fidl::encoding::ResourceTypeMarker for Spec {
        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 Spec {
        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<Spec, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut Spec
    {
        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::<Spec>(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<4096>, fidl::encoding::DefaultFuchsiaResourceDialect>(
            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 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<Annotation, 1024>, fidl::encoding::DefaultFuchsiaResourceDialect>(
            self.annotations.as_mut().map(<fidl::encoding::Vector<Annotation, 1024> 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 Spec {
        #[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<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>,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::BoundedString<4096>,
                    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<Annotation, 1024> 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.annotations.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<Annotation, 1024>, fidl::encoding::DefaultFuchsiaResourceDialect));
                fidl::decode!(fidl::encoding::Vector<Annotation, 1024>, 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 ViewSpec {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.viewport_creation_token {
                return 4;
            }
            if let Some(_) = self.annotations {
                return 3;
            }
            if let Some(_) = self.view_ref {
                return 2;
            }
            if let Some(_) = self.view_holder_token {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ViewSpec {
        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 ViewSpec {
        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<ViewSpec, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut ViewSpec
    {
        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::<ViewSpec>(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_fuchsia_ui_views::ViewHolderToken, fidl::encoding::DefaultFuchsiaResourceDialect>(
            self.view_holder_token.as_mut().map(<fidl_fuchsia_ui_views::ViewHolderToken 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_fuchsia_ui_views::ViewRef, fidl::encoding::DefaultFuchsiaResourceDialect>(
            self.view_ref.as_mut().map(<fidl_fuchsia_ui_views::ViewRef 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::encoding::Vector<Annotation, 1024>, fidl::encoding::DefaultFuchsiaResourceDialect>(
            self.annotations.as_mut().map(<fidl::encoding::Vector<Annotation, 1024> 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_ui_views::ViewportCreationToken, fidl::encoding::DefaultFuchsiaResourceDialect>(
            self.viewport_creation_token.as_mut().map(<fidl_fuchsia_ui_views::ViewportCreationToken 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 ViewSpec {
        #[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_fuchsia_ui_views::ViewHolderToken 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.view_holder_token.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl_fuchsia_ui_views::ViewHolderToken,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl_fuchsia_ui_views::ViewHolderToken,
                    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_fuchsia_ui_views::ViewRef 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.view_ref.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl_fuchsia_ui_views::ViewRef,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl_fuchsia_ui_views::ViewRef,
                    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::Vector<Annotation, 1024> 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.annotations.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<Annotation, 1024>, fidl::encoding::DefaultFuchsiaResourceDialect));
                fidl::decode!(fidl::encoding::Vector<Annotation, 1024>, 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_ui_views::ViewportCreationToken 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.viewport_creation_token.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl_fuchsia_ui_views::ViewportCreationToken,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl_fuchsia_ui_views::ViewportCreationToken,
                    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 fidl::encoding::ResourceTypeMarker for AnnotationValue {
        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 AnnotationValue {
        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<AnnotationValue, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut AnnotationValue
    {
        #[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::<AnnotationValue>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
            AnnotationValue::Text(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedString, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            AnnotationValue::Buffer(ref mut val) => {
                fidl::encoding::encode_in_envelope::<fidl_fuchsia_mem::Buffer, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <fidl_fuchsia_mem::Buffer as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
                    encoder, offset + 8, _depth
                )
            }
        }
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for AnnotationValue
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::Text(fidl::new_empty!(
                fidl::encoding::UnboundedString,
                fidl::encoding::DefaultFuchsiaResourceDialect
            ))
        }

        #[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 => <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context,
                ),
                2 => <fidl_fuchsia_mem::Buffer as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context,
                ),
                _ => return Err(fidl::Error::UnknownUnionTag),
            };

            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 AnnotationValue::Text(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = AnnotationValue::Text(fidl::new_empty!(
                            fidl::encoding::UnboundedString,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let AnnotationValue::Text(ref mut val) = self {
                        fidl::decode!(
                            fidl::encoding::UnboundedString,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                2 => {
                    #[allow(irrefutable_let_patterns)]
                    if let AnnotationValue::Buffer(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = AnnotationValue::Buffer(fidl::new_empty!(
                            fidl_fuchsia_mem::Buffer,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let AnnotationValue::Buffer(ref mut val) = self {
                        fidl::decode!(
                            fidl_fuchsia_mem::Buffer,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                ordinal => panic!("unexpected 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(())
        }
    }
}