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

// fidl_experiment = no_optional_structs
// fidl_experiment = simple_empty_response_syntax
// fidl_experiment = unknown_interactions

#![allow(
    unused_parens, // one-element-tuple-case is not a tuple
    unused_mut, // not all args require mutation, but many do
    nonstandard_style, // auto-caps does its best, but is not always successful
)]
#![recursion_limit = "512"]

#[cfg(target_os = "fuchsia")]
#[allow(unused_imports)]
use fuchsia_zircon as zx;

#[allow(unused_imports)]
use {
    bitflags::bitflags,
    fidl::{
        client::QueryResponseFut,
        encoding::zerocopy,
        endpoints::{ControlHandle as _, Responder as _},
        fidl_bits, fidl_enum, fidl_struct, fidl_table, fidl_union,
    },
    fuchsia_zircon_status as zx_status,
    futures::future::{self, MaybeDone, TryFutureExt},
};

const _FIDL_TRACE_BINDINGS_RUST: u32 = 6;
bitflags! {
    /// The flags associated with an opened file.
    pub struct FileFlags: u64 {
        /// The owner can read the file.
        const RIGHT_READABLE = 1;
        /// The owner can write to fhe file.
        const RIGHT_WRITABLE = 2;
        /// The file is a directory.
        const DIRECTORY = 4096;
    }
}

impl FileFlags {
    #[inline(always)]
    pub fn from_bits_allow_unknown(bits: u64) -> Self {
        unsafe { Self::from_bits_unchecked(bits) }
    }

    #[inline(always)]
    pub fn has_unknown_bits(&self) -> bool {
        self.get_unknown_bits() != 0
    }

    #[inline(always)]
    pub fn get_unknown_bits(&self) -> u64 {
        self.bits & !Self::all().bits
    }
}

fidl_bits! {
    name: FileFlags,
    prim_ty: u64,
    flexible: true,
}

pub const MAX_PATH_LENGTH: u64 = 4095;

pub const MAX_REQUEST_COUNT: u64 = 16;

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(C)]
pub struct BinderIoctlRequest {
    pub tid: u64,
    pub request: u32,
    pub parameter: u64,
}

impl fidl::encoding::TopLevel for BinderIoctlRequest {}

fidl_struct! {
    copy: true,
    name: BinderIoctlRequest,
    members: [
        tid {
            ty: u64,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        request {
            ty: u32,
            index: 1,
            typevar: T1,
            offset_v1: 8,
            offset_v2: 8,
        },
        parameter {
            ty: u64,
            index: 2,
            typevar: T2,
            offset_v1: 16,
            offset_v2: 16,
        },
    ],
    padding_v1: [
        {
            ty: u64,
            offset: 8,
            mask: 0xffffffff00000000u64,
        },
    ],
    padding_v2: [
        {
            ty: u64,
            offset: 8,
            mask: 0xffffffff00000000u64,
        },
    ],
    size_v1: 24,
    size_v2: 24,
    align_v1: 8,
    align_v2: 8,
}

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct BinderSetVmoRequest {
    pub vmo: fidl::Vmo,
    pub mapped_address: u64,
}

impl fidl::encoding::TopLevel for BinderSetVmoRequest {}

fidl_struct! {
    name: BinderSetVmoRequest,
    resource: true,
    members: [
        vmo {
            ty: fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>,
            resource: true,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        mapped_address {
            ty: u64,
            index: 1,
            typevar: T1,
            offset_v1: 8,
            offset_v2: 8,
        },
    ],
    padding_v1: [
        {
            ty: u64,
            offset: 0,
            mask: 0xffffffff00000000u64,
        },
    ],
    padding_v2: [
        {
            ty: u64,
            offset: 0,
            mask: 0xffffffff00000000u64,
        },
    ],
    size_v1: 16,
    size_v2: 16,
    align_v1: 8,
    align_v2: 8,
}

/// The representation of an open file that can be transferred between the
/// binder device driver and the client.
#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct FileHandle {
    /// The handle connecting to the file protocol. If not present, the file
    /// should behave as it is was a null file: all read must succeed with empty
    /// content and all write must succeed. See `fdio_fd_create_null()`.
    pub file: Option<fidl::Handle>,
    /// The flags associated with the opened file.
    pub flags: FileFlags,
}

impl fidl::encoding::TopLevel for FileHandle {}

fidl_struct! {
    name: FileHandle,
    resource: true,
    members: [
        file {
            ty: fidl::encoding::Optional<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>>,
            resource: true,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        flags {
            ty: FileFlags,
            index: 1,
            typevar: T1,
            offset_v1: 8,
            offset_v2: 8,
        },
    ],
    padding_v1: [
        {
            ty: u64,
            offset: 0,
            mask: 0xffffffff00000000u64,
        },
    ],
    padding_v2: [
        {
            ty: u64,
            offset: 0,
            mask: 0xffffffff00000000u64,
        },
    ],
    size_v1: 16,
    size_v2: 16,
    align_v1: 8,
    align_v2: 8,
}

#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct ProcessAccessorReadMemoryRequest {
    pub address: u64,
    pub length: u64,
}

impl fidl::encoding::TopLevel for ProcessAccessorReadMemoryRequest {}

fidl_struct! {
    copy: true,
    name: ProcessAccessorReadMemoryRequest,
    members: [
        address {
            ty: u64,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        length {
            ty: u64,
            index: 1,
            typevar: T1,
            offset_v1: 8,
            offset_v2: 8,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 16,
    size_v2: 16,
    align_v1: 8,
    align_v2: 8,
}

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct ProcessAccessorWriteMemoryRequest {
    pub address: u64,
    pub content: fidl::Vmo,
}

impl fidl::encoding::TopLevel for ProcessAccessorWriteMemoryRequest {}

fidl_struct! {
    name: ProcessAccessorWriteMemoryRequest,
    resource: true,
    members: [
        address {
            ty: u64,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        content {
            ty: fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>,
            resource: true,
            index: 1,
            typevar: T1,
            offset_v1: 8,
            offset_v2: 8,
        },
    ],
    padding_v1: [
        {
            ty: u64,
            offset: 8,
            mask: 0xffffffff00000000u64,
        },
    ],
    padding_v2: [
        {
            ty: u64,
            offset: 8,
            mask: 0xffffffff00000000u64,
        },
    ],
    size_v1: 16,
    size_v2: 16,
    align_v1: 8,
    align_v2: 8,
}

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct ProcessAccessorReadMemoryResponse {
    pub content: fidl::Vmo,
}

impl fidl::encoding::TopLevel for ProcessAccessorReadMemoryResponse {}

fidl_struct! {
    name: ProcessAccessorReadMemoryResponse,
    resource: true,
    members: [
        content {
            ty: fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>,
            resource: true,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 4,
    size_v2: 4,
    align_v1: 4,
    align_v2: 4,
}

#[derive(Debug, PartialEq)]
pub struct DevBinderOpenRequest {
    /// The path to the binder device in the starnix process.
    /// Mandatory
    pub path: Option<Vec<u8>>,
    /// The service giving the binder driver access to the resources of the client process.
    pub process_accessor: Option<fidl::endpoints::ClientEnd<ProcessAccessorMarker>>,
    /// The request to the Binder protocol implementation.
    /// Mandatory
    pub binder: Option<fidl::endpoints::ServerEnd<BinderMarker>>,
    #[deprecated = "Use `..DevBinderOpenRequest::EMPTY` to construct and `..` to match."]
    #[doc(hidden)]
    pub __non_exhaustive: (),
}

impl DevBinderOpenRequest {
    /// An empty table with every field set to `None`.
    #[allow(deprecated)]
    pub const EMPTY: Self =
        Self { path: None, process_accessor: None, binder: None, __non_exhaustive: () };
}

impl fidl::encoding::TopLevel for DevBinderOpenRequest {}

fidl_table! {
    name: DevBinderOpenRequest,
    resource: true,
    members: [
        path {
            ty: fidl::encoding::UnboundedVector<u8>,
            ordinal: 1,
        },
        process_accessor {
            ty: fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ProcessAccessorMarker>>,
            resource: true,
            ordinal: 2,
        },
        binder {
            ty: fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<BinderMarker>>,
            resource: true,
            ordinal: 3,
        },
    ],
}

#[derive(Debug, PartialEq)]
pub struct FileRequest {
    /// The list of file descriptor the client must close.
    pub close_requests: Option<Vec<i32>>,
    /// The list of file descriptor the client must duplicate and transfer to
    /// the binder driver.
    pub get_requests: Option<Vec<i32>>,
    /// The list of open file the client must add to its fd table, returning
    /// the new minted file descriptors.
    pub add_requests: Option<Vec<FileHandle>>,
    #[deprecated = "Use `..FileRequest::EMPTY` to construct and `..` to match."]
    #[doc(hidden)]
    pub __non_exhaustive: (),
}

impl FileRequest {
    /// An empty table with every field set to `None`.
    #[allow(deprecated)]
    pub const EMPTY: Self =
        Self { close_requests: None, get_requests: None, add_requests: None, __non_exhaustive: () };
}

impl fidl::encoding::TopLevel for FileRequest {}

fidl_table! {
    name: FileRequest,
    resource: true,
    members: [
        close_requests {
            ty: fidl::encoding::UnboundedVector<i32>,
            ordinal: 1,
        },
        get_requests {
            ty: fidl::encoding::UnboundedVector<i32>,
            ordinal: 2,
        },
        add_requests {
            ty: fidl::encoding::UnboundedVector<FileHandle>,
            resource: true,
            ordinal: 3,
        },
    ],
}

#[derive(Debug, PartialEq)]
pub struct FileResponse {
    /// The list of open file retriever for the `get_requests`.
    pub get_responses: Option<Vec<FileHandle>>,
    /// The list of file descriptors minted for the `add_requests`.
    pub add_responses: Option<Vec<i32>>,
    #[deprecated = "Use `..FileResponse::EMPTY` to construct and `..` to match."]
    #[doc(hidden)]
    pub __non_exhaustive: (),
}

impl FileResponse {
    /// An empty table with every field set to `None`.
    #[allow(deprecated)]
    pub const EMPTY: Self = Self { get_responses: None, add_responses: None, __non_exhaustive: () };
}

impl fidl::encoding::TopLevel for FileResponse {}

fidl_table! {
    name: FileResponse,
    resource: true,
    members: [
        get_responses {
            ty: fidl::encoding::UnboundedVector<FileHandle>,
            resource: true,
            ordinal: 2,
        },
        add_responses {
            ty: fidl::encoding::UnboundedVector<i32>,
            ordinal: 3,
        },
    ],
}

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

impl fidl::endpoints::ProtocolMarker for BinderMarker {
    type Proxy = BinderProxy;
    type RequestStream = BinderRequestStream;
    const DEBUG_NAME: &'static str = "(anonymous) Binder";
}
pub type BinderIoctlResult = Result<(), fidl_fuchsia_posix::Errno>;

pub trait BinderProxyInterface: Send + Sync {
    fn r#set_vmo(&self, vmo: fidl::Vmo, mapped_address: u64) -> Result<(), fidl::Error>;
    type IoctlResponseFut: std::future::Future<Output = Result<BinderIoctlResult, fidl::Error>>
        + Send;
    fn r#ioctl(&self, tid: u64, request: u32, parameter: u64) -> Self::IoctlResponseFut;
}

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

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

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

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(&self, deadline: zx::Time) -> Result<BinderEvent, fidl::Error> {
        BinderEvent::decode(self.client.wait_for_event(deadline)?)
    }
    /// Set the VMO to used as a share resource between the driver and the
    /// client. `mapped_address` is the address where the vmo is mapped in the
    /// client address space.
    pub fn r#set_vmo(
        &self,
        mut vmo: fidl::Vmo,
        mut mapped_address: u64,
    ) -> Result<(), fidl::Error> {
        self.client.send::<BinderSetVmoRequest, false>(
            (vmo, mapped_address),
            0x43ee5d8f7d3acbf6,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    pub fn r#ioctl(
        &self,
        mut tid: u64,
        mut request: u32,
        mut parameter: u64,
        ___deadline: zx::Time,
    ) -> Result<BinderIoctlResult, fidl::Error> {
        let _response = self.client.send_query::<BinderIoctlRequest, fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >, false, false>(
            (tid, request, parameter),
            0x1032021e21310000,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

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

    /// Get a Stream of events from the remote end of the Binder protocol
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> BinderEventStream {
        BinderEventStream { event_receiver: self.client.take_event_receiver() }
    }
    /// Set the VMO to used as a share resource between the driver and the
    /// client. `mapped_address` is the address where the vmo is mapped in the
    /// client address space.
    pub fn r#set_vmo(
        &self,
        mut vmo: fidl::Vmo,
        mut mapped_address: u64,
    ) -> Result<(), fidl::Error> {
        BinderProxyInterface::r#set_vmo(self, vmo, mapped_address)
    }
    pub fn r#ioctl(
        &self,
        mut tid: u64,
        mut request: u32,
        mut parameter: u64,
    ) -> fidl::client::QueryResponseFut<BinderIoctlResult> {
        BinderProxyInterface::r#ioctl(self, tid, request, parameter)
    }
}

impl BinderProxyInterface for BinderProxy {
    fn r#set_vmo(&self, mut vmo: fidl::Vmo, mut mapped_address: u64) -> Result<(), fidl::Error> {
        self.client.send::<BinderSetVmoRequest, false>(
            (vmo, mapped_address),
            0x43ee5d8f7d3acbf6,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    type IoctlResponseFut = fidl::client::QueryResponseFut<BinderIoctlResult>;
    fn r#ioctl(
        &self,
        mut tid: u64,
        mut request: u32,
        mut parameter: u64,
    ) -> Self::IoctlResponseFut {
        fn _decode(
            mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
        ) -> Result<BinderIoctlResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                false,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<BinderIoctlRequest, BinderIoctlResult, false>(
            (tid, request, parameter),
            0x1032021e21310000,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

pub struct BinderEventStream {
    event_receiver: fidl::client::EventReceiver,
}

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

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

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

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

        std::task::Poll::Ready(Some(BinderEvent::decode(buf)))
    }
}

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

impl BinderEvent {
    /// Decodes a message buffer as a [`BinderEvent`]. Transaction
    /// ID in the message must be zero; this method does not check TXID.
    fn decode(mut buf: fidl::MessageBufEtc) -> Result<BinderEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

        match tx_header.ordinal() {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal(),
                protocol_name: <BinderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

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

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

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

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

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

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

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.poll_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled BinderRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf(|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))))
                }
            }

            // A message has been received from the channel
            let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
            if !header.is_compatible() {
                return std::task::Poll::Ready(Some(Err(fidl::Error::IncompatibleMagicNumber(
                    header.magic_number(),
                ))));
            }

            std::task::Poll::Ready(Some(match header.ordinal() {
                0x43ee5d8f7d3acbf6 => {
                    let mut req = fidl::new_empty!(BinderSetVmoRequest);
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.starnix.binder/BinderSetVmoRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into::<BinderSetVmoRequest>(
                        &header,
                        _body_bytes,
                        handles,
                        &mut req,
                    )?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = BinderControlHandle { inner: this.inner.clone() };

                    Ok(BinderRequest::SetVmo {
                        vmo: req.vmo,
                        mapped_address: req.mapped_address,

                        control_handle,
                    })
                }
                0x1032021e21310000 => {
                    let mut req = fidl::new_empty!(BinderIoctlRequest);
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.starnix.binder/BinderIoctlRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into::<BinderIoctlRequest>(
                        &header,
                        _body_bytes,
                        handles,
                        &mut req,
                    )?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = BinderControlHandle { inner: this.inner.clone() };

                    Ok(BinderRequest::Ioctl {
                        tid: req.tid,
                        request: req.request,
                        parameter: req.parameter,

                        responder: BinderIoctlResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id(),
                            ordinal: header.ordinal(),
                        },
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal(),
                    protocol_name: <BinderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
        })
    }
}
/// An opened connection to a binder driver.
#[derive(Debug)]
pub enum BinderRequest {
    /// Set the VMO to used as a share resource between the driver and the
    /// client. `mapped_address` is the address where the vmo is mapped in the
    /// client address space.
    SetVmo {
        vmo: fidl::Vmo,
        mapped_address: u64,
        control_handle: BinderControlHandle,
    },
    Ioctl {
        tid: u64,
        request: u32,
        parameter: u64,
        responder: BinderIoctlResponder,
    },
}

impl BinderRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_set_vmo(self) -> Option<(fidl::Vmo, u64, BinderControlHandle)> {
        if let BinderRequest::SetVmo { vmo, mapped_address, control_handle } = self {
            Some((vmo, mapped_address, control_handle))
        } else {
            None
        }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_ioctl(self) -> Option<(u64, u32, u64, BinderIoctlResponder)> {
        if let BinderRequest::Ioctl { tid, request, parameter, responder } = self {
            Some((tid, request, parameter, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            BinderRequest::SetVmo { .. } => "set_vmo",
            BinderRequest::Ioctl { .. } => "ioctl",
        }
    }
}

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

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

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

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }

    fn on_closed<'a>(&'a self) -> fidl::OnSignals<'a> {
        self.inner.channel().on_closed()
    }
}

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

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

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

    /// Similar to "send" but does not shutdown the channel if
    /// an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: &mut BinderIoctlResult,
    ) -> Result<(), fidl::Error> {
        let r = self.send_raw(result);
        self.drop_without_shutdown();
        r
    }

    fn send_raw(&self, mut result: &mut BinderIoctlResult) -> Result<(), fidl::Error> {
        let msg = fidl::encoding::TransactionMessage {
            header: fidl::encoding::TransactionHeader::new(
                self.tx_id,
                self.ordinal,
                fidl::encoding::DynamicFlags::empty(),
            ),
            body: *result,
        };

        fidl::encoding::with_tls_encode_buf(|bytes, handles| {
            fidl::duration_begin!("fidl", "encode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.starnix.binder/BinderIoctlResponse");
            fidl::encoding::Encoder::encode::<
                fidl::encoding::TransactionMessageType<
                    fidl::encoding::ResultType<
                        fidl::encoding::EmptyStruct,
                        fidl_fuchsia_posix::Errno,
                    >,
                >,
            >(bytes, handles, msg)?;
            fidl::trace_blob!("fidl:blob", "encode", bytes.as_slice());
            fidl::duration_end!("fidl", "encode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);

            self.control_handle.inner.send_raw_msg(&*bytes, &mut *handles)
        })
    }
}

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

impl fidl::endpoints::ProtocolMarker for DevBinderMarker {
    type Proxy = DevBinderProxy;
    type RequestStream = DevBinderRequestStream;
    const DEBUG_NAME: &'static str = "fuchsia.starnix.binder.DevBinder";
}
impl fidl::endpoints::DiscoverableProtocolMarker for DevBinderMarker {}

pub trait DevBinderProxyInterface: Send + Sync {
    fn r#open(&self, payload: DevBinderOpenRequest) -> Result<(), fidl::Error>;
}

#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct DevBinderSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl DevBinderSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <DevBinderMarker 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::Time) -> Result<DevBinderEvent, fidl::Error> {
        DevBinderEvent::decode(self.client.wait_for_event(deadline)?)
    }
    /// Open the binder device node.
    pub fn r#open(&self, mut payload: DevBinderOpenRequest) -> Result<(), fidl::Error> {
        self.client.send::<DevBinderOpenRequest, false>(
            &mut payload,
            0x250f5ee034977685,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[derive(Debug, Clone)]
pub struct DevBinderProxy {
    client: fidl::client::Client,
}

impl fidl::endpoints::Proxy for DevBinderProxy {
    type Protocol = DevBinderMarker;

    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 DevBinderProxy {
    /// Create a new Proxy for DevBinder
    pub fn new(channel: fidl::AsyncChannel) -> Self {
        let protocol_name = <DevBinderMarker 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 DevBinder protocol
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> DevBinderEventStream {
        DevBinderEventStream { event_receiver: self.client.take_event_receiver() }
    }
    /// Open the binder device node.
    pub fn r#open(&self, mut payload: DevBinderOpenRequest) -> Result<(), fidl::Error> {
        DevBinderProxyInterface::r#open(self, payload)
    }
}

impl DevBinderProxyInterface for DevBinderProxy {
    fn r#open(&self, mut payload: DevBinderOpenRequest) -> Result<(), fidl::Error> {
        self.client.send::<DevBinderOpenRequest, false>(
            &mut payload,
            0x250f5ee034977685,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

pub struct DevBinderEventStream {
    event_receiver: fidl::client::EventReceiver,
}

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

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

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

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

        std::task::Poll::Ready(Some(DevBinderEvent::decode(buf)))
    }
}

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

impl DevBinderEvent {
    /// Decodes a message buffer as a [`DevBinderEvent`]. Transaction
    /// ID in the message must be zero; this method does not check TXID.
    fn decode(mut buf: fidl::MessageBufEtc) -> Result<DevBinderEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

        match tx_header.ordinal() {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal(),
                protocol_name: <DevBinderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for DevBinder
pub struct DevBinderRequestStream {
    inner: std::sync::Arc<fidl::ServeInner>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for DevBinderRequestStream {
    type Protocol = DevBinderMarker;
    type ControlHandle = DevBinderControlHandle;

    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 {
        DevBinderControlHandle { inner: self.inner.clone() }
    }

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

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

impl futures::Stream for DevBinderRequestStream {
    type Item = Result<DevBinderRequest, 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.poll_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled DevBinderRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf(|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))))
                }
            }

            // A message has been received from the channel
            let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
            if !header.is_compatible() {
                return std::task::Poll::Ready(Some(Err(fidl::Error::IncompatibleMagicNumber(
                    header.magic_number(),
                ))));
            }

            std::task::Poll::Ready(Some(match header.ordinal() {
                0x250f5ee034977685 => {
                    let mut req = fidl::new_empty!(DevBinderOpenRequest);
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.starnix.binder/DevBinderOpenRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    fidl::encoding::maybe_overflowing_decode::<DevBinderOpenRequest>(
                        &header,
                        _body_bytes,
                        handles,
                        &mut req,
                    )?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = DevBinderControlHandle { inner: this.inner.clone() };

                    Ok(DevBinderRequest::Open { payload: req, control_handle })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal(),
                    protocol_name: <DevBinderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
        })
    }
}
/// Give access to the binder nodes.
#[derive(Debug)]
pub enum DevBinderRequest {
    /// Open the binder device node.
    Open { payload: DevBinderOpenRequest, control_handle: DevBinderControlHandle },
}

impl DevBinderRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_open(self) -> Option<(DevBinderOpenRequest, DevBinderControlHandle)> {
        if let DevBinderRequest::Open { payload, control_handle } = self {
            Some((payload, control_handle))
        } else {
            None
        }
    }

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

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

impl fidl::endpoints::ControlHandle for DevBinderControlHandle {
    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<'a>(&'a self) -> fidl::OnSignals<'a> {
        self.inner.channel().on_closed()
    }
}

impl DevBinderControlHandle {}

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

impl fidl::endpoints::ProtocolMarker for ProcessAccessorMarker {
    type Proxy = ProcessAccessorProxy;
    type RequestStream = ProcessAccessorRequestStream;
    const DEBUG_NAME: &'static str = "(anonymous) ProcessAccessor";
}
pub type ProcessAccessorWriteMemoryResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type ProcessAccessorReadMemoryResult = Result<fidl::Vmo, fidl_fuchsia_posix::Errno>;
pub type ProcessAccessorFileRequestResult = Result<FileResponse, fidl_fuchsia_posix::Errno>;

pub trait ProcessAccessorProxyInterface: Send + Sync {
    type WriteMemoryResponseFut: std::future::Future<Output = Result<ProcessAccessorWriteMemoryResult, fidl::Error>>
        + Send;
    fn r#write_memory(&self, address: u64, content: fidl::Vmo) -> Self::WriteMemoryResponseFut;
    type ReadMemoryResponseFut: std::future::Future<Output = Result<ProcessAccessorReadMemoryResult, fidl::Error>>
        + Send;
    fn r#read_memory(&self, address: u64, length: u64) -> Self::ReadMemoryResponseFut;
    type FileRequestResponseFut: std::future::Future<Output = Result<ProcessAccessorFileRequestResult, fidl::Error>>
        + Send;
    #[allow(unused_variables)]
    fn r#file_request(&self, payload: FileRequest) -> Self::FileRequestResponseFut {
        unimplemented!("transitional method file_request is unimplemented");
    }
}

#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ProcessAccessorSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl ProcessAccessorSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <ProcessAccessorMarker 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::Time) -> Result<ProcessAccessorEvent, fidl::Error> {
        ProcessAccessorEvent::decode(self.client.wait_for_event(deadline)?)
    }
    /// Writes the contents of `content` to `address` in the process memory,
    /// using the vmo content size to determine the number of bytes to write.
    pub fn r#write_memory(
        &self,
        mut address: u64,
        mut content: fidl::Vmo,
        ___deadline: zx::Time,
    ) -> Result<ProcessAccessorWriteMemoryResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<ProcessAccessorWriteMemoryRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >, false, false>(
                    (address, content),
                    0x666cda7c6b6d4819,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }
    /// Returns the `length` bytes of the memory of the process at `address` in
    /// the `content` vmo. Th returned vmo's content size must always be exactly
    /// `length`.
    pub fn r#read_memory(
        &self,
        mut address: u64,
        mut length: u64,
        ___deadline: zx::Time,
    ) -> Result<ProcessAccessorReadMemoryResult, fidl::Error> {
        let _response =
            self.client.send_query::<ProcessAccessorReadMemoryRequest, fidl::encoding::ResultType<
                ProcessAccessorReadMemoryResponse,
                fidl_fuchsia_posix::Errno,
            >, false, false>(
                (address, length),
                0x2282a725977b36e5,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.content))
    }
    /// Execute the given `request` and returns the associated `response`. Any
    /// failure will interrupt further processing and fail this operation and
    /// the associated errno will be then returned.
    /// The implementator of this protocol should handle these requests as best
    /// it can so that a failure doesn't have visible side-effects.
    pub fn r#file_request(
        &self,
        mut payload: FileRequest,
        ___deadline: zx::Time,
    ) -> Result<ProcessAccessorFileRequestResult, fidl::Error> {
        let _response = self.client.send_query::<FileRequest, fidl::encoding::ResultType<
            FileResponse,
            fidl_fuchsia_posix::Errno,
        >, false, true>(
            &mut payload,
            0xd42103a37c3f0a,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

#[derive(Debug, Clone)]
pub struct ProcessAccessorProxy {
    client: fidl::client::Client,
}

impl fidl::endpoints::Proxy for ProcessAccessorProxy {
    type Protocol = ProcessAccessorMarker;

    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 ProcessAccessorProxy {
    /// Create a new Proxy for ProcessAccessor
    pub fn new(channel: fidl::AsyncChannel) -> Self {
        let protocol_name = <ProcessAccessorMarker 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 ProcessAccessor protocol
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> ProcessAccessorEventStream {
        ProcessAccessorEventStream { event_receiver: self.client.take_event_receiver() }
    }
    /// Writes the contents of `content` to `address` in the process memory,
    /// using the vmo content size to determine the number of bytes to write.
    pub fn r#write_memory(
        &self,
        mut address: u64,
        mut content: fidl::Vmo,
    ) -> fidl::client::QueryResponseFut<ProcessAccessorWriteMemoryResult> {
        ProcessAccessorProxyInterface::r#write_memory(self, address, content)
    }
    /// Returns the `length` bytes of the memory of the process at `address` in
    /// the `content` vmo. Th returned vmo's content size must always be exactly
    /// `length`.
    pub fn r#read_memory(
        &self,
        mut address: u64,
        mut length: u64,
    ) -> fidl::client::QueryResponseFut<ProcessAccessorReadMemoryResult> {
        ProcessAccessorProxyInterface::r#read_memory(self, address, length)
    }
    /// Execute the given `request` and returns the associated `response`. Any
    /// failure will interrupt further processing and fail this operation and
    /// the associated errno will be then returned.
    /// The implementator of this protocol should handle these requests as best
    /// it can so that a failure doesn't have visible side-effects.
    pub fn r#file_request(
        &self,
        mut payload: FileRequest,
    ) -> fidl::client::QueryResponseFut<ProcessAccessorFileRequestResult> {
        ProcessAccessorProxyInterface::r#file_request(self, payload)
    }
}

impl ProcessAccessorProxyInterface for ProcessAccessorProxy {
    type WriteMemoryResponseFut = fidl::client::QueryResponseFut<ProcessAccessorWriteMemoryResult>;
    fn r#write_memory(
        &self,
        mut address: u64,
        mut content: fidl::Vmo,
    ) -> Self::WriteMemoryResponseFut {
        fn _decode(
            mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
        ) -> Result<ProcessAccessorWriteMemoryResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                false,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            ProcessAccessorWriteMemoryRequest,
            ProcessAccessorWriteMemoryResult,
            false,
        >(
            (address, content,),
            0x666cda7c6b6d4819,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
    type ReadMemoryResponseFut = fidl::client::QueryResponseFut<ProcessAccessorReadMemoryResult>;
    fn r#read_memory(&self, mut address: u64, mut length: u64) -> Self::ReadMemoryResponseFut {
        fn _decode(
            mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
        ) -> Result<ProcessAccessorReadMemoryResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    ProcessAccessorReadMemoryResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                false,
            >(_buf?)?;
            Ok(_response.map(|x| x.content))
        }
        self.client.send_query_and_decode::<
            ProcessAccessorReadMemoryRequest,
            ProcessAccessorReadMemoryResult,
            false,
        >(
            (address, length,),
            0x2282a725977b36e5,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
    type FileRequestResponseFut = fidl::client::QueryResponseFut<ProcessAccessorFileRequestResult>;
    fn r#file_request(&self, mut payload: FileRequest) -> Self::FileRequestResponseFut {
        fn _decode(
            mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
        ) -> Result<ProcessAccessorFileRequestResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<FileResponse, fidl_fuchsia_posix::Errno>,
                true,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<FileRequest, ProcessAccessorFileRequestResult, false>(
            &mut payload,
            0xd42103a37c3f0a,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

pub struct ProcessAccessorEventStream {
    event_receiver: fidl::client::EventReceiver,
}

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

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

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

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

        std::task::Poll::Ready(Some(ProcessAccessorEvent::decode(buf)))
    }
}

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

impl ProcessAccessorEvent {
    /// Decodes a message buffer as a [`ProcessAccessorEvent`]. Transaction
    /// ID in the message must be zero; this method does not check TXID.
    fn decode(mut buf: fidl::MessageBufEtc) -> Result<ProcessAccessorEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

        match tx_header.ordinal() {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal(),
                protocol_name:
                    <ProcessAccessorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for ProcessAccessor
pub struct ProcessAccessorRequestStream {
    inner: std::sync::Arc<fidl::ServeInner>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for ProcessAccessorRequestStream {
    type Protocol = ProcessAccessorMarker;
    type ControlHandle = ProcessAccessorControlHandle;

    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 {
        ProcessAccessorControlHandle { inner: self.inner.clone() }
    }

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

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

impl futures::Stream for ProcessAccessorRequestStream {
    type Item = Result<ProcessAccessorRequest, 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.poll_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled ProcessAccessorRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf(|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))))
                }
            }

            // A message has been received from the channel
            let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
            if !header.is_compatible() {
                return std::task::Poll::Ready(Some(Err(fidl::Error::IncompatibleMagicNumber(
                    header.magic_number(),
                ))));
            }

            std::task::Poll::Ready(Some(match header.ordinal() {
                0x666cda7c6b6d4819 => {
                    let mut req = fidl::new_empty!(ProcessAccessorWriteMemoryRequest);
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.starnix.binder/ProcessAccessorWriteMemoryRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into::<ProcessAccessorWriteMemoryRequest>(
                        &header,
                        _body_bytes,
                        handles,
                        &mut req,
                    )?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = ProcessAccessorControlHandle { inner: this.inner.clone() };

                    Ok(ProcessAccessorRequest::WriteMemory {
                        address: req.address,
                        content: req.content,

                        responder: ProcessAccessorWriteMemoryResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id(),
                            ordinal: header.ordinal(),
                        },
                    })
                }
                0x2282a725977b36e5 => {
                    let mut req = fidl::new_empty!(ProcessAccessorReadMemoryRequest);
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.starnix.binder/ProcessAccessorReadMemoryRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into::<ProcessAccessorReadMemoryRequest>(
                        &header,
                        _body_bytes,
                        handles,
                        &mut req,
                    )?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = ProcessAccessorControlHandle { inner: this.inner.clone() };

                    Ok(ProcessAccessorRequest::ReadMemory {
                        address: req.address,
                        length: req.length,

                        responder: ProcessAccessorReadMemoryResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id(),
                            ordinal: header.ordinal(),
                        },
                    })
                }
                0xd42103a37c3f0a => {
                    let mut req = fidl::new_empty!(FileRequest);
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.starnix.binder/ProcessAccessorFileRequestRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    fidl::encoding::maybe_overflowing_decode::<FileRequest>(
                        &header,
                        _body_bytes,
                        handles,
                        &mut req,
                    )?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = ProcessAccessorControlHandle { inner: this.inner.clone() };

                    Ok(ProcessAccessorRequest::FileRequest {
                        payload: req,
                        responder: ProcessAccessorFileRequestResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id(),
                            ordinal: header.ordinal(),
                        },
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal(),
                    protocol_name:
                        <ProcessAccessorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
        })
    }
}
/// Protocol that gives the binder driver access to the client process'
/// resources.
#[derive(Debug)]
pub enum ProcessAccessorRequest {
    /// Writes the contents of `content` to `address` in the process memory,
    /// using the vmo content size to determine the number of bytes to write.
    WriteMemory { address: u64, content: fidl::Vmo, responder: ProcessAccessorWriteMemoryResponder },
    /// Returns the `length` bytes of the memory of the process at `address` in
    /// the `content` vmo. Th returned vmo's content size must always be exactly
    /// `length`.
    ReadMemory { address: u64, length: u64, responder: ProcessAccessorReadMemoryResponder },
    /// Execute the given `request` and returns the associated `response`. Any
    /// failure will interrupt further processing and fail this operation and
    /// the associated errno will be then returned.
    /// The implementator of this protocol should handle these requests as best
    /// it can so that a failure doesn't have visible side-effects.
    FileRequest { payload: FileRequest, responder: ProcessAccessorFileRequestResponder },
}

impl ProcessAccessorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_write_memory(
        self,
    ) -> Option<(u64, fidl::Vmo, ProcessAccessorWriteMemoryResponder)> {
        if let ProcessAccessorRequest::WriteMemory { address, content, responder } = self {
            Some((address, content, responder))
        } else {
            None
        }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_read_memory(self) -> Option<(u64, u64, ProcessAccessorReadMemoryResponder)> {
        if let ProcessAccessorRequest::ReadMemory { address, length, responder } = self {
            Some((address, length, responder))
        } else {
            None
        }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_file_request(self) -> Option<(FileRequest, ProcessAccessorFileRequestResponder)> {
        if let ProcessAccessorRequest::FileRequest { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            ProcessAccessorRequest::WriteMemory { .. } => "write_memory",
            ProcessAccessorRequest::ReadMemory { .. } => "read_memory",
            ProcessAccessorRequest::FileRequest { .. } => "file_request",
        }
    }
}

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

impl fidl::endpoints::ControlHandle for ProcessAccessorControlHandle {
    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<'a>(&'a self) -> fidl::OnSignals<'a> {
        self.inner.channel().on_closed()
    }
}

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

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

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

    /// Similar to "send" but does not shutdown the channel if
    /// an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: &mut ProcessAccessorWriteMemoryResult,
    ) -> Result<(), fidl::Error> {
        let r = self.send_raw(result);
        self.drop_without_shutdown();
        r
    }

    fn send_raw(
        &self,
        mut result: &mut ProcessAccessorWriteMemoryResult,
    ) -> Result<(), fidl::Error> {
        let msg = fidl::encoding::TransactionMessage {
            header: fidl::encoding::TransactionHeader::new(
                self.tx_id,
                self.ordinal,
                fidl::encoding::DynamicFlags::empty(),
            ),
            body: *result,
        };

        fidl::encoding::with_tls_encode_buf(|bytes, handles| {
            fidl::duration_begin!("fidl", "encode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.starnix.binder/ProcessAccessorWriteMemoryResponse");
            fidl::encoding::Encoder::encode::<
                fidl::encoding::TransactionMessageType<
                    fidl::encoding::ResultType<
                        fidl::encoding::EmptyStruct,
                        fidl_fuchsia_posix::Errno,
                    >,
                >,
            >(bytes, handles, msg)?;
            fidl::trace_blob!("fidl:blob", "encode", bytes.as_slice());
            fidl::duration_end!("fidl", "encode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);

            self.control_handle.inner.send_raw_msg(&*bytes, &mut *handles)
        })
    }
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct ProcessAccessorReadMemoryResponder {
    control_handle: std::mem::ManuallyDrop<ProcessAccessorControlHandle>,
    tx_id: u32,
    ordinal: u64,
}

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

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

    /// Similar to "send" but does not shutdown the channel if
    /// an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: &mut ProcessAccessorReadMemoryResult,
    ) -> Result<(), fidl::Error> {
        let r = self.send_raw(result);
        self.drop_without_shutdown();
        r
    }

    fn send_raw(
        &self,
        mut result: &mut ProcessAccessorReadMemoryResult,
    ) -> Result<(), fidl::Error> {
        let msg = fidl::encoding::TransactionMessage {
            header: fidl::encoding::TransactionHeader::new(
                self.tx_id,
                self.ordinal,
                fidl::encoding::DynamicFlags::empty(),
            ),
            body: result
                .as_mut()
                .map_err(|e| *e)
                .map(|content| (std::mem::replace(content, fidl::Handle::invalid().into()),)),
        };

        fidl::encoding::with_tls_encode_buf(|bytes, handles| {
            fidl::duration_begin!("fidl", "encode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.starnix.binder/ProcessAccessorReadMemoryResponse");
            fidl::encoding::Encoder::encode::<
                fidl::encoding::TransactionMessageType<
                    fidl::encoding::ResultType<
                        ProcessAccessorReadMemoryResponse,
                        fidl_fuchsia_posix::Errno,
                    >,
                >,
            >(bytes, handles, msg)?;
            fidl::trace_blob!("fidl:blob", "encode", bytes.as_slice());
            fidl::duration_end!("fidl", "encode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);

            self.control_handle.inner.send_raw_msg(&*bytes, &mut *handles)
        })
    }
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct ProcessAccessorFileRequestResponder {
    control_handle: std::mem::ManuallyDrop<ProcessAccessorControlHandle>,
    tx_id: u32,
    ordinal: u64,
}

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

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

    /// Similar to "send" but does not shutdown the channel if
    /// an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: &mut ProcessAccessorFileRequestResult,
    ) -> Result<(), fidl::Error> {
        let r = self.send_raw(result);
        self.drop_without_shutdown();
        r
    }

    fn send_raw(
        &self,
        mut result: &mut ProcessAccessorFileRequestResult,
    ) -> Result<(), fidl::Error> {
        let msg = fidl::encoding::TransactionMessage {
            header: fidl::encoding::TransactionHeader::new(
                self.tx_id,
                self.ordinal,
                fidl::encoding::DynamicFlags::empty(),
            ),
            body: result.as_mut().map_err(|e| *e),
        };

        fidl::encoding::with_tls_encode_buf(|bytes, handles| {
            fidl::duration_begin!("fidl", "encode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.starnix.binder/ProcessAccessorFileRequestResponse");
            fidl::encoding::Encoder::encode::<
                fidl::encoding::TransactionMessageType<
                    fidl::encoding::ResultType<FileResponse, fidl_fuchsia_posix::Errno>,
                >,
            >(bytes, handles, msg)?;
            fidl::trace_blob!("fidl:blob", "encode", bytes.as_slice());
            fidl::duration_end!("fidl", "encode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);

            self.control_handle.inner.send_raw_msg(&*bytes, &mut *handles)
        })
    }
}