fidl_fuchsia_hardware_block/

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct BlockOpenSessionRequest {
    pub session: fidl::endpoints::ServerEnd<SessionMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct BlockOpenSessionWithOffsetMapRequest {
    pub session: fidl::endpoints::ServerEnd<SessionMarker>,
    pub offset_map: Option<fidl::endpoints::ClientEnd<OffsetMapMarker>>,
    pub initial_mappings: Option<Vec<BlockOffsetMapping>>,
}

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

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

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

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

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct SessionGetFifoResponse {
    pub fifo: fidl::Fifo,
}

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

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

impl fidl::endpoints::ProtocolMarker for BlockMarker {
    type Proxy = BlockProxy;
    type RequestStream = BlockRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = BlockSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) Block";
}
pub type BlockGetInfoResult = Result<BlockInfo, i32>;
pub type BlockGetStatsResult = Result<BlockStats, i32>;

pub trait BlockProxyInterface: Send + Sync {
    type GetInfoResponseFut: std::future::Future<Output = Result<BlockGetInfoResult, fidl::Error>>
        + Send;
    fn r#get_info(&self) -> Self::GetInfoResponseFut;
    type GetStatsResponseFut: std::future::Future<Output = Result<BlockGetStatsResult, fidl::Error>>
        + Send;
    fn r#get_stats(&self, clear: bool) -> Self::GetStatsResponseFut;
    fn r#open_session(
        &self,
        session: fidl::endpoints::ServerEnd<SessionMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#open_session_with_offset_map(
        &self,
        session: fidl::endpoints::ServerEnd<SessionMarker>,
        offset_map: Option<fidl::endpoints::ClientEnd<OffsetMapMarker>>,
        initial_mappings: Option<&[BlockOffsetMapping]>,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct BlockSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for BlockSynchronousProxy {
    type Proxy = BlockProxy;
    type Protocol = BlockMarker;

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

    /// Get information about the underlying block device.
    pub fn r#get_info(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BlockGetInfoResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<BlockGetInfoResponse, i32>,
        >(
            (),
            0x79df1a5cdb6cc6a3,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.info))
    }

    /// Returns stats about block device operations. Setting `clear` will reset stats counters.
    pub fn r#get_stats(
        &self,
        mut clear: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BlockGetStatsResult, fidl::Error> {
        let _response = self.client.send_query::<
            BlockGetStatsRequest,
            fidl::encoding::ResultType<BlockGetStatsResponse, i32>,
        >(
            (clear,),
            0x53d9542a778385ae,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.stats))
    }

    /// Opens a new FIFO-based session on the block device.
    pub fn r#open_session(
        &self,
        mut session: fidl::endpoints::ServerEnd<SessionMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<BlockOpenSessionRequest>(
            (session,),
            0x7241c68d17614a31,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Opens a new FIFO-based session on the block device, providing an offset lookup map which
    /// transparently translates device offsets in block FIFO requests.
    ///
    /// `initial_mappings` is a static set of mappings which the server can immediately use.  If
    /// `offset_map` is not provided, this must be non-empty, and requests that fall outside of the
    /// mapped range will fail.
    ///
    /// If `offset_map` is provided, whenever the server receives a request with a dev_offset that
    /// falls outside of the known range, it will consult `offset_map` to attempt to resolve the
    /// offset.  Because these offset mappings must be stable for the duration of the session, the
    /// server may cache any mappings.
    ///
    /// This interface is intended to be used internally between nested Block implementations, in
    /// order to provide passthrough I/O.  For example, a fixed partition map (e.g. GPT) will serve
    /// a Block protocol for each partition, and will respond to OpenSession requests by calling
    /// OpenSessionWithOffsetMap on the underlying block device, establishing itself as the source
    /// for translating client block offsets (relative to the partition start) to absolute offsets.
    /// The client can then communicate directly with the underlying block device, and the partition
    /// offsets can be transparently applied to requests.
    pub fn r#open_session_with_offset_map(
        &self,
        mut session: fidl::endpoints::ServerEnd<SessionMarker>,
        mut offset_map: Option<fidl::endpoints::ClientEnd<OffsetMapMarker>>,
        mut initial_mappings: Option<&[BlockOffsetMapping]>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<BlockOpenSessionWithOffsetMapRequest>(
            (session, offset_map, initial_mappings),
            0x7a8d3ba3d8bfa10f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::Proxy for BlockProxy {
    type Protocol = BlockMarker;

    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 BlockProxy {
    /// Create a new Proxy for fuchsia.hardware.block/Block.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <BlockMarker 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) -> BlockEventStream {
        BlockEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Get information about the underlying block device.
    pub fn r#get_info(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BlockGetInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BlockProxyInterface::r#get_info(self)
    }

    /// Returns stats about block device operations. Setting `clear` will reset stats counters.
    pub fn r#get_stats(
        &self,
        mut clear: bool,
    ) -> fidl::client::QueryResponseFut<
        BlockGetStatsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BlockProxyInterface::r#get_stats(self, clear)
    }

    /// Opens a new FIFO-based session on the block device.
    pub fn r#open_session(
        &self,
        mut session: fidl::endpoints::ServerEnd<SessionMarker>,
    ) -> Result<(), fidl::Error> {
        BlockProxyInterface::r#open_session(self, session)
    }

    /// Opens a new FIFO-based session on the block device, providing an offset lookup map which
    /// transparently translates device offsets in block FIFO requests.
    ///
    /// `initial_mappings` is a static set of mappings which the server can immediately use.  If
    /// `offset_map` is not provided, this must be non-empty, and requests that fall outside of the
    /// mapped range will fail.
    ///
    /// If `offset_map` is provided, whenever the server receives a request with a dev_offset that
    /// falls outside of the known range, it will consult `offset_map` to attempt to resolve the
    /// offset.  Because these offset mappings must be stable for the duration of the session, the
    /// server may cache any mappings.
    ///
    /// This interface is intended to be used internally between nested Block implementations, in
    /// order to provide passthrough I/O.  For example, a fixed partition map (e.g. GPT) will serve
    /// a Block protocol for each partition, and will respond to OpenSession requests by calling
    /// OpenSessionWithOffsetMap on the underlying block device, establishing itself as the source
    /// for translating client block offsets (relative to the partition start) to absolute offsets.
    /// The client can then communicate directly with the underlying block device, and the partition
    /// offsets can be transparently applied to requests.
    pub fn r#open_session_with_offset_map(
        &self,
        mut session: fidl::endpoints::ServerEnd<SessionMarker>,
        mut offset_map: Option<fidl::endpoints::ClientEnd<OffsetMapMarker>>,
        mut initial_mappings: Option<&[BlockOffsetMapping]>,
    ) -> Result<(), fidl::Error> {
        BlockProxyInterface::r#open_session_with_offset_map(
            self,
            session,
            offset_map,
            initial_mappings,
        )
    }
}

impl BlockProxyInterface for BlockProxy {
    type GetInfoResponseFut = fidl::client::QueryResponseFut<
        BlockGetInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_info(&self) -> Self::GetInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BlockGetInfoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<BlockGetInfoResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x79df1a5cdb6cc6a3,
            >(_buf?)?;
            Ok(_response.map(|x| x.info))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, BlockGetInfoResult>(
            (),
            0x79df1a5cdb6cc6a3,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetStatsResponseFut = fidl::client::QueryResponseFut<
        BlockGetStatsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_stats(&self, mut clear: bool) -> Self::GetStatsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BlockGetStatsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<BlockGetStatsResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x53d9542a778385ae,
            >(_buf?)?;
            Ok(_response.map(|x| x.stats))
        }
        self.client.send_query_and_decode::<BlockGetStatsRequest, BlockGetStatsResult>(
            (clear,),
            0x53d9542a778385ae,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#open_session(
        &self,
        mut session: fidl::endpoints::ServerEnd<SessionMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<BlockOpenSessionRequest>(
            (session,),
            0x7241c68d17614a31,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#open_session_with_offset_map(
        &self,
        mut session: fidl::endpoints::ServerEnd<SessionMarker>,
        mut offset_map: Option<fidl::endpoints::ClientEnd<OffsetMapMarker>>,
        mut initial_mappings: Option<&[BlockOffsetMapping]>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<BlockOpenSessionWithOffsetMapRequest>(
            (session, offset_map, initial_mappings),
            0x7a8d3ba3d8bfa10f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.hardware.block/Block.
pub struct BlockRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for BlockRequestStream {
    type Protocol = BlockMarker;
    type ControlHandle = BlockControlHandle;

    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 {
        BlockControlHandle { 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 BlockRequestStream {
    type Item = Result<BlockRequest, 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 BlockRequestStream 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 {
                    0x79df1a5cdb6cc6a3 => {
                        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 = BlockControlHandle { inner: this.inner.clone() };
                        Ok(BlockRequest::GetInfo {
                            responder: BlockGetInfoResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x53d9542a778385ae => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BlockGetStatsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BlockGetStatsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BlockControlHandle { inner: this.inner.clone() };
                        Ok(BlockRequest::GetStats {
                            clear: req.clear,

                            responder: BlockGetStatsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7241c68d17614a31 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            BlockOpenSessionRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BlockOpenSessionRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BlockControlHandle { inner: this.inner.clone() };
                        Ok(BlockRequest::OpenSession { session: req.session, control_handle })
                    }
                    0x7a8d3ba3d8bfa10f => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            BlockOpenSessionWithOffsetMapRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BlockOpenSessionWithOffsetMapRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BlockControlHandle { inner: this.inner.clone() };
                        Ok(BlockRequest::OpenSessionWithOffsetMap {
                            session: req.session,
                            offset_map: req.offset_map,
                            initial_mappings: req.initial_mappings,

                            control_handle,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name: <BlockMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Defines access to a device which is accessible in block-granularity chunks
/// for reading and writing.
#[derive(Debug)]
pub enum BlockRequest {
    /// Get information about the underlying block device.
    GetInfo { responder: BlockGetInfoResponder },
    /// Returns stats about block device operations. Setting `clear` will reset stats counters.
    GetStats { clear: bool, responder: BlockGetStatsResponder },
    /// Opens a new FIFO-based session on the block device.
    OpenSession {
        session: fidl::endpoints::ServerEnd<SessionMarker>,
        control_handle: BlockControlHandle,
    },
    /// Opens a new FIFO-based session on the block device, providing an offset lookup map which
    /// transparently translates device offsets in block FIFO requests.
    ///
    /// `initial_mappings` is a static set of mappings which the server can immediately use.  If
    /// `offset_map` is not provided, this must be non-empty, and requests that fall outside of the
    /// mapped range will fail.
    ///
    /// If `offset_map` is provided, whenever the server receives a request with a dev_offset that
    /// falls outside of the known range, it will consult `offset_map` to attempt to resolve the
    /// offset.  Because these offset mappings must be stable for the duration of the session, the
    /// server may cache any mappings.
    ///
    /// This interface is intended to be used internally between nested Block implementations, in
    /// order to provide passthrough I/O.  For example, a fixed partition map (e.g. GPT) will serve
    /// a Block protocol for each partition, and will respond to OpenSession requests by calling
    /// OpenSessionWithOffsetMap on the underlying block device, establishing itself as the source
    /// for translating client block offsets (relative to the partition start) to absolute offsets.
    /// The client can then communicate directly with the underlying block device, and the partition
    /// offsets can be transparently applied to requests.
    OpenSessionWithOffsetMap {
        session: fidl::endpoints::ServerEnd<SessionMarker>,
        offset_map: Option<fidl::endpoints::ClientEnd<OffsetMapMarker>>,
        initial_mappings: Option<Vec<BlockOffsetMapping>>,
        control_handle: BlockControlHandle,
    },
}

impl BlockRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_info(self) -> Option<(BlockGetInfoResponder)> {
        if let BlockRequest::GetInfo { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_stats(self) -> Option<(bool, BlockGetStatsResponder)> {
        if let BlockRequest::GetStats { clear, responder } = self {
            Some((clear, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_open_session(
        self,
    ) -> Option<(fidl::endpoints::ServerEnd<SessionMarker>, BlockControlHandle)> {
        if let BlockRequest::OpenSession { session, control_handle } = self {
            Some((session, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_open_session_with_offset_map(
        self,
    ) -> Option<(
        fidl::endpoints::ServerEnd<SessionMarker>,
        Option<fidl::endpoints::ClientEnd<OffsetMapMarker>>,
        Option<Vec<BlockOffsetMapping>>,
        BlockControlHandle,
    )> {
        if let BlockRequest::OpenSessionWithOffsetMap {
            session,
            offset_map,
            initial_mappings,
            control_handle,
        } = self
        {
            Some((session, offset_map, initial_mappings, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            BlockRequest::GetInfo { .. } => "get_info",
            BlockRequest::GetStats { .. } => "get_stats",
            BlockRequest::OpenSession { .. } => "open_session",
            BlockRequest::OpenSessionWithOffsetMap { .. } => "open_session_with_offset_map",
        }
    }
}

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

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

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

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

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

    fn send_raw(&self, mut result: Result<&BlockInfo, i32>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<BlockGetInfoResponse, i32>>(
            result.map(|info| (info,)),
            self.tx_id,
            0x79df1a5cdb6cc6a3,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut result: Result<&BlockStats, i32>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<BlockGetStatsResponse, i32>>(
            result.map(|stats| (stats,)),
            self.tx_id,
            0x53d9542a778385ae,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for FtlMarker {
    type Proxy = FtlProxy;
    type RequestStream = FtlRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = FtlSynchronousProxy;

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

pub trait FtlProxyInterface: Send + Sync {
    type GetVmoResponseFut: std::future::Future<Output = Result<InspectVmoProviderGetVmoResult, fidl::Error>>
        + Send;
    fn r#get_vmo(&self) -> Self::GetVmoResponseFut;
    type FormatResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#format(&self) -> Self::FormatResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct FtlSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for FtlSynchronousProxy {
    type Proxy = FtlProxy;
    type Protocol = FtlMarker;

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

    /// Requests the inspect vmo from the entity.
    ///  - |vmo| has |ZX_RIGHTS_DUPLICATE|, |ZX_RIGHTS_TRANSFER|, |ZX_RIGHTS_READ|
    pub fn r#get_vmo(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<InspectVmoProviderGetVmoResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<InspectVmoProviderGetVmoResponse, i32>,
        >(
            (),
            0xf523185c6e67738,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.vmo))
    }

    /// Discards previous contents and reinitializes the device.
    pub fn r#format(&self, ___deadline: zx::MonotonicInstant) -> Result<i32, fidl::Error> {
        let _response = self.client.send_query::<fidl::encoding::EmptyPayload, FtlFormatResponse>(
            (),
            0x79751d9c0b48a0d6,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.status)
    }
}

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

impl fidl::endpoints::Proxy for FtlProxy {
    type Protocol = FtlMarker;

    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 FtlProxy {
    /// Create a new Proxy for fuchsia.hardware.block/Ftl.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <FtlMarker 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) -> FtlEventStream {
        FtlEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Requests the inspect vmo from the entity.
    ///  - |vmo| has |ZX_RIGHTS_DUPLICATE|, |ZX_RIGHTS_TRANSFER|, |ZX_RIGHTS_READ|
    pub fn r#get_vmo(
        &self,
    ) -> fidl::client::QueryResponseFut<
        InspectVmoProviderGetVmoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        FtlProxyInterface::r#get_vmo(self)
    }

    /// Discards previous contents and reinitializes the device.
    pub fn r#format(
        &self,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        FtlProxyInterface::r#format(self)
    }
}

impl FtlProxyInterface for FtlProxy {
    type GetVmoResponseFut = fidl::client::QueryResponseFut<
        InspectVmoProviderGetVmoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_vmo(&self) -> Self::GetVmoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<InspectVmoProviderGetVmoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<InspectVmoProviderGetVmoResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xf523185c6e67738,
            >(_buf?)?;
            Ok(_response.map(|x| x.vmo))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, InspectVmoProviderGetVmoResult>(
                (),
                0xf523185c6e67738,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type FormatResponseFut =
        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#format(&self) -> Self::FormatResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                FtlFormatResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x79751d9c0b48a0d6,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, i32>(
            (),
            0x79751d9c0b48a0d6,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.hardware.block/Ftl.
pub struct FtlRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for FtlRequestStream {
    type Protocol = FtlMarker;
    type ControlHandle = FtlControlHandle;

    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 {
        FtlControlHandle { 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 FtlRequestStream {
    type Item = Result<FtlRequest, 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 FtlRequestStream 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 {
                    0xf523185c6e67738 => {
                        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 = FtlControlHandle { inner: this.inner.clone() };
                        Ok(FtlRequest::GetVmo {
                            responder: FtlGetVmoResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x79751d9c0b48a0d6 => {
                        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 = FtlControlHandle { inner: this.inner.clone() };
                        Ok(FtlRequest::Format {
                            responder: FtlFormatResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name: <FtlMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

#[derive(Debug)]
pub enum FtlRequest {
    /// Requests the inspect vmo from the entity.
    ///  - |vmo| has |ZX_RIGHTS_DUPLICATE|, |ZX_RIGHTS_TRANSFER|, |ZX_RIGHTS_READ|
    GetVmo { responder: FtlGetVmoResponder },
    /// Discards previous contents and reinitializes the device.
    Format { responder: FtlFormatResponder },
}

impl FtlRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_vmo(self) -> Option<(FtlGetVmoResponder)> {
        if let FtlRequest::GetVmo { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_format(self) -> Option<(FtlFormatResponder)> {
        if let FtlRequest::Format { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            FtlRequest::GetVmo { .. } => "get_vmo",
            FtlRequest::Format { .. } => "format",
        }
    }
}

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

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

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

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

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

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

    fn send_raw(&self, mut result: Result<fidl::Vmo, i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<InspectVmoProviderGetVmoResponse, i32>>(
                result.map(|vmo| (vmo,)),
                self.tx_id,
                0xf523185c6e67738,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

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

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

    fn send_raw(&self, mut status: i32) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<FtlFormatResponse>(
            (status,),
            self.tx_id,
            0x79751d9c0b48a0d6,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for InspectVmoProviderMarker {
    type Proxy = InspectVmoProviderProxy;
    type RequestStream = InspectVmoProviderRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = InspectVmoProviderSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) InspectVmoProvider";
}
pub type InspectVmoProviderGetVmoResult = Result<fidl::Vmo, i32>;

pub trait InspectVmoProviderProxyInterface: Send + Sync {
    type GetVmoResponseFut: std::future::Future<Output = Result<InspectVmoProviderGetVmoResult, fidl::Error>>
        + Send;
    fn r#get_vmo(&self) -> Self::GetVmoResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct InspectVmoProviderSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for InspectVmoProviderSynchronousProxy {
    type Proxy = InspectVmoProviderProxy;
    type Protocol = InspectVmoProviderMarker;

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

    /// Requests the inspect vmo from the entity.
    ///  - |vmo| has |ZX_RIGHTS_DUPLICATE|, |ZX_RIGHTS_TRANSFER|, |ZX_RIGHTS_READ|
    pub fn r#get_vmo(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<InspectVmoProviderGetVmoResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<InspectVmoProviderGetVmoResponse, i32>,
        >(
            (),
            0xf523185c6e67738,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.vmo))
    }
}

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

impl fidl::endpoints::Proxy for InspectVmoProviderProxy {
    type Protocol = InspectVmoProviderMarker;

    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 InspectVmoProviderProxy {
    /// Create a new Proxy for fuchsia.hardware.block/InspectVmoProvider.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <InspectVmoProviderMarker 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) -> InspectVmoProviderEventStream {
        InspectVmoProviderEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Requests the inspect vmo from the entity.
    ///  - |vmo| has |ZX_RIGHTS_DUPLICATE|, |ZX_RIGHTS_TRANSFER|, |ZX_RIGHTS_READ|
    pub fn r#get_vmo(
        &self,
    ) -> fidl::client::QueryResponseFut<
        InspectVmoProviderGetVmoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        InspectVmoProviderProxyInterface::r#get_vmo(self)
    }
}

impl InspectVmoProviderProxyInterface for InspectVmoProviderProxy {
    type GetVmoResponseFut = fidl::client::QueryResponseFut<
        InspectVmoProviderGetVmoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_vmo(&self) -> Self::GetVmoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<InspectVmoProviderGetVmoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<InspectVmoProviderGetVmoResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xf523185c6e67738,
            >(_buf?)?;
            Ok(_response.map(|x| x.vmo))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, InspectVmoProviderGetVmoResult>(
                (),
                0xf523185c6e67738,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.hardware.block/InspectVmoProvider.
pub struct InspectVmoProviderRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for InspectVmoProviderRequestStream {
    type Protocol = InspectVmoProviderMarker;
    type ControlHandle = InspectVmoProviderControlHandle;

    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 {
        InspectVmoProviderControlHandle { 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 InspectVmoProviderRequestStream {
    type Item = Result<InspectVmoProviderRequest, 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 InspectVmoProviderRequestStream 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 {
                0xf523185c6e67738 => {
                    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 = InspectVmoProviderControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(InspectVmoProviderRequest::GetVmo {
                        responder: InspectVmoProviderGetVmoResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <InspectVmoProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// It is treated as a separate protocol for extension if necessary.
#[derive(Debug)]
pub enum InspectVmoProviderRequest {
    /// Requests the inspect vmo from the entity.
    ///  - |vmo| has |ZX_RIGHTS_DUPLICATE|, |ZX_RIGHTS_TRANSFER|, |ZX_RIGHTS_READ|
    GetVmo { responder: InspectVmoProviderGetVmoResponder },
}

impl InspectVmoProviderRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_vmo(self) -> Option<(InspectVmoProviderGetVmoResponder)> {
        if let InspectVmoProviderRequest::GetVmo { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

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

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

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

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

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

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

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

    fn send_raw(&self, mut result: Result<fidl::Vmo, i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<InspectVmoProviderGetVmoResponse, i32>>(
                result.map(|vmo| (vmo,)),
                self.tx_id,
                0xf523185c6e67738,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

impl fidl::endpoints::ProtocolMarker for OffsetMapMarker {
    type Proxy = OffsetMapProxy;
    type RequestStream = OffsetMapRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = OffsetMapSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) OffsetMap";
}
pub type OffsetMapQueryResult = Result<Vec<BlockOffsetMapping>, i32>;

pub trait OffsetMapProxyInterface: Send + Sync {
    type QueryResponseFut: std::future::Future<Output = Result<OffsetMapQueryResult, fidl::Error>>
        + Send;
    fn r#query(&self, source_block_offset: u64, length: u64) -> Self::QueryResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct OffsetMapSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for OffsetMapSynchronousProxy {
    type Proxy = OffsetMapProxy;
    type Protocol = OffsetMapMarker;

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

    /// Looks up mappings which contain `[source_block_offset, source_block_offset + length)`.
    /// The returned mappings will always overlap with a prefix of the requested range, but might
    /// not contain the entire range (for example if there are many discontiguous extents).  The
    /// caller can simply repeat the call to query for the remaining suffix of the range.
    ///
    /// These mappings are guaranteed to be stable in the lifetime of the OffsetMap connection.
    pub fn r#query(
        &self,
        mut source_block_offset: u64,
        mut length: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<OffsetMapQueryResult, fidl::Error> {
        let _response = self.client.send_query::<
            OffsetMapQueryRequest,
            fidl::encoding::ResultType<OffsetMapQueryResponse, i32>,
        >(
            (source_block_offset, length,),
            0x18471939852e45a4,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.mappings))
    }
}

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

impl fidl::endpoints::Proxy for OffsetMapProxy {
    type Protocol = OffsetMapMarker;

    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 OffsetMapProxy {
    /// Create a new Proxy for fuchsia.hardware.block/OffsetMap.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <OffsetMapMarker 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) -> OffsetMapEventStream {
        OffsetMapEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Looks up mappings which contain `[source_block_offset, source_block_offset + length)`.
    /// The returned mappings will always overlap with a prefix of the requested range, but might
    /// not contain the entire range (for example if there are many discontiguous extents).  The
    /// caller can simply repeat the call to query for the remaining suffix of the range.
    ///
    /// These mappings are guaranteed to be stable in the lifetime of the OffsetMap connection.
    pub fn r#query(
        &self,
        mut source_block_offset: u64,
        mut length: u64,
    ) -> fidl::client::QueryResponseFut<
        OffsetMapQueryResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        OffsetMapProxyInterface::r#query(self, source_block_offset, length)
    }
}

impl OffsetMapProxyInterface for OffsetMapProxy {
    type QueryResponseFut = fidl::client::QueryResponseFut<
        OffsetMapQueryResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#query(&self, mut source_block_offset: u64, mut length: u64) -> Self::QueryResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<OffsetMapQueryResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<OffsetMapQueryResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x18471939852e45a4,
            >(_buf?)?;
            Ok(_response.map(|x| x.mappings))
        }
        self.client.send_query_and_decode::<OffsetMapQueryRequest, OffsetMapQueryResult>(
            (source_block_offset, length),
            0x18471939852e45a4,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.hardware.block/OffsetMap.
pub struct OffsetMapRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for OffsetMapRequestStream {
    type Protocol = OffsetMapMarker;
    type ControlHandle = OffsetMapControlHandle;

    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 {
        OffsetMapControlHandle { 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 OffsetMapRequestStream {
    type Item = Result<OffsetMapRequest, 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 OffsetMapRequestStream 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 {
                    0x18471939852e45a4 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            OffsetMapQueryRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<OffsetMapQueryRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = OffsetMapControlHandle { inner: this.inner.clone() };
                        Ok(OffsetMapRequest::Query {
                            source_block_offset: req.source_block_offset,
                            length: req.length,

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

/// See Block/OpenSessionWithOffsetMap.
#[derive(Debug)]
pub enum OffsetMapRequest {
    /// Looks up mappings which contain `[source_block_offset, source_block_offset + length)`.
    /// The returned mappings will always overlap with a prefix of the requested range, but might
    /// not contain the entire range (for example if there are many discontiguous extents).  The
    /// caller can simply repeat the call to query for the remaining suffix of the range.
    ///
    /// These mappings are guaranteed to be stable in the lifetime of the OffsetMap connection.
    Query { source_block_offset: u64, length: u64, responder: OffsetMapQueryResponder },
}

impl OffsetMapRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_query(self) -> Option<(u64, u64, OffsetMapQueryResponder)> {
        if let OffsetMapRequest::Query { source_block_offset, length, responder } = self {
            Some((source_block_offset, length, responder))
        } else {
            None
        }
    }

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

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

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

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

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

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

    fn send_raw(&self, mut result: Result<&[BlockOffsetMapping], i32>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<OffsetMapQueryResponse, i32>>(
            result.map(|mappings| (mappings,)),
            self.tx_id,
            0x18471939852e45a4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for SessionMarker {
    type Proxy = SessionProxy;
    type RequestStream = SessionRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = SessionSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) Session";
}
pub type SessionGetFifoResult = Result<fidl::Fifo, i32>;
pub type SessionAttachVmoResult = Result<VmoId, i32>;

pub trait SessionProxyInterface: Send + Sync {
    type CloseResponseFut: std::future::Future<
            Output = Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error>,
        > + Send;
    fn r#close(&self) -> Self::CloseResponseFut;
    type GetFifoResponseFut: std::future::Future<Output = Result<SessionGetFifoResult, fidl::Error>>
        + Send;
    fn r#get_fifo(&self) -> Self::GetFifoResponseFut;
    type AttachVmoResponseFut: std::future::Future<Output = Result<SessionAttachVmoResult, fidl::Error>>
        + Send;
    fn r#attach_vmo(&self, vmo: fidl::Vmo) -> Self::AttachVmoResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct SessionSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for SessionSynchronousProxy {
    type Proxy = SessionProxy;
    type Protocol = SessionMarker;

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

    /// Terminates the connection.
    ///
    /// After calling `Close`, the client must not send any other requests.
    ///
    /// Servers, after sending the status response, should close the connection
    /// regardless of status and without sending an epitaph.
    ///
    /// Closing the client end of the channel should be semantically equivalent
    /// to calling `Close` without knowing when the close has completed or its
    /// status.
    pub fn r#close(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (),
            0x5ac5d459ad7f657e,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Returns a handle to the client end of the FIFO.
    pub fn r#get_fifo(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SessionGetFifoResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<SessionGetFifoResponse, i32>,
        >(
            (),
            0x61a31a92a206b7d5,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.fifo))
    }

    /// Attaches a VMO to the session.
    ///
    /// Returns an identifer that can be used to refer to the VMO.
    pub fn r#attach_vmo(
        &self,
        mut vmo: fidl::Vmo,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SessionAttachVmoResult, fidl::Error> {
        let _response = self.client.send_query::<
            SessionAttachVmoRequest,
            fidl::encoding::ResultType<SessionAttachVmoResponse, i32>,
        >(
            (vmo,),
            0x54edc4641d9569f5,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.vmoid))
    }
}

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

impl fidl::endpoints::Proxy for SessionProxy {
    type Protocol = SessionMarker;

    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 SessionProxy {
    /// Create a new Proxy for fuchsia.hardware.block/Session.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <SessionMarker 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) -> SessionEventStream {
        SessionEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Terminates the connection.
    ///
    /// After calling `Close`, the client must not send any other requests.
    ///
    /// Servers, after sending the status response, should close the connection
    /// regardless of status and without sending an epitaph.
    ///
    /// Closing the client end of the channel should be semantically equivalent
    /// to calling `Close` without knowing when the close has completed or its
    /// status.
    pub fn r#close(
        &self,
    ) -> fidl::client::QueryResponseFut<
        fidl_fuchsia_unknown::CloseableCloseResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SessionProxyInterface::r#close(self)
    }

    /// Returns a handle to the client end of the FIFO.
    pub fn r#get_fifo(
        &self,
    ) -> fidl::client::QueryResponseFut<
        SessionGetFifoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SessionProxyInterface::r#get_fifo(self)
    }

    /// Attaches a VMO to the session.
    ///
    /// Returns an identifer that can be used to refer to the VMO.
    pub fn r#attach_vmo(
        &self,
        mut vmo: fidl::Vmo,
    ) -> fidl::client::QueryResponseFut<
        SessionAttachVmoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SessionProxyInterface::r#attach_vmo(self, vmo)
    }
}

impl SessionProxyInterface for SessionProxy {
    type CloseResponseFut = fidl::client::QueryResponseFut<
        fidl_fuchsia_unknown::CloseableCloseResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#close(&self) -> Self::CloseResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5ac5d459ad7f657e,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            fidl_fuchsia_unknown::CloseableCloseResult,
        >(
            (),
            0x5ac5d459ad7f657e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetFifoResponseFut = fidl::client::QueryResponseFut<
        SessionGetFifoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_fifo(&self) -> Self::GetFifoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SessionGetFifoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<SessionGetFifoResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x61a31a92a206b7d5,
            >(_buf?)?;
            Ok(_response.map(|x| x.fifo))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, SessionGetFifoResult>(
            (),
            0x61a31a92a206b7d5,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type AttachVmoResponseFut = fidl::client::QueryResponseFut<
        SessionAttachVmoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#attach_vmo(&self, mut vmo: fidl::Vmo) -> Self::AttachVmoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SessionAttachVmoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<SessionAttachVmoResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x54edc4641d9569f5,
            >(_buf?)?;
            Ok(_response.map(|x| x.vmoid))
        }
        self.client.send_query_and_decode::<SessionAttachVmoRequest, SessionAttachVmoResult>(
            (vmo,),
            0x54edc4641d9569f5,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.hardware.block/Session.
pub struct SessionRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for SessionRequestStream {
    type Protocol = SessionMarker;
    type ControlHandle = SessionControlHandle;

    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 {
        SessionControlHandle { 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 SessionRequestStream {
    type Item = Result<SessionRequest, 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 SessionRequestStream 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 {
                    0x5ac5d459ad7f657e => {
                        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 = SessionControlHandle { inner: this.inner.clone() };
                        Ok(SessionRequest::Close {
                            responder: SessionCloseResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x61a31a92a206b7d5 => {
                        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 = SessionControlHandle { inner: this.inner.clone() };
                        Ok(SessionRequest::GetFifo {
                            responder: SessionGetFifoResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x54edc4641d9569f5 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SessionAttachVmoRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SessionAttachVmoRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SessionControlHandle { inner: this.inner.clone() };
                        Ok(SessionRequest::AttachVmo {
                            vmo: req.vmo,

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

/// Represents a session with a block device.
///
/// This protocol encodes the underlying object's lifetime in both directions; the underlying object
/// is alive iff both ends of the protocol are open. That is:
///
/// - Closing the client end causes the object to be destroyed.
/// - Observing a closure of the server end indicates the object no longer exists.
///
/// The object can be destroyed synchronously using [`fuchsia.unknown/Closeable.Close`].
#[derive(Debug)]
pub enum SessionRequest {
    /// Terminates the connection.
    ///
    /// After calling `Close`, the client must not send any other requests.
    ///
    /// Servers, after sending the status response, should close the connection
    /// regardless of status and without sending an epitaph.
    ///
    /// Closing the client end of the channel should be semantically equivalent
    /// to calling `Close` without knowing when the close has completed or its
    /// status.
    Close { responder: SessionCloseResponder },
    /// Returns a handle to the client end of the FIFO.
    GetFifo { responder: SessionGetFifoResponder },
    /// Attaches a VMO to the session.
    ///
    /// Returns an identifer that can be used to refer to the VMO.
    AttachVmo { vmo: fidl::Vmo, responder: SessionAttachVmoResponder },
}

impl SessionRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_close(self) -> Option<(SessionCloseResponder)> {
        if let SessionRequest::Close { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_fifo(self) -> Option<(SessionGetFifoResponder)> {
        if let SessionRequest::GetFifo { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_attach_vmo(self) -> Option<(fidl::Vmo, SessionAttachVmoResponder)> {
        if let SessionRequest::AttachVmo { vmo, responder } = self {
            Some((vmo, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            SessionRequest::Close { .. } => "close",
            SessionRequest::GetFifo { .. } => "get_fifo",
            SessionRequest::AttachVmo { .. } => "attach_vmo",
        }
    }
}

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

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

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut result: Result<fidl::Fifo, i32>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<SessionGetFifoResponse, i32>>(
            result.map(|fifo| (fifo,)),
            self.tx_id,
            0x61a31a92a206b7d5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut result: Result<&VmoId, i32>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<SessionAttachVmoResponse, i32>>(
            result.map(|vmoid| (vmoid,)),
            self.tx_id,
            0x54edc4641d9569f5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

mod internal {
    use super::*;

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

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

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

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

    impl fidl::encoding::ResourceTypeMarker for BlockOpenSessionWithOffsetMapRequest {
        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 BlockOpenSessionWithOffsetMapRequest {
        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<
            BlockOpenSessionWithOffsetMapRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut BlockOpenSessionWithOffsetMapRequest
    {
        #[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::<BlockOpenSessionWithOffsetMapRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<BlockOpenSessionWithOffsetMapRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<SessionMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.session),
                    <fidl::encoding::Optional<fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<OffsetMapMarker>>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.offset_map),
                    <fidl::encoding::Optional<fidl::encoding::Vector<BlockOffsetMapping, 64>> as fidl::encoding::ValueTypeMarker>::borrow(&self.initial_mappings),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<SessionMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<OffsetMapMarker>>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T2: fidl::encoding::Encode<
                fidl::encoding::Optional<fidl::encoding::Vector<BlockOffsetMapping, 64>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            BlockOpenSessionWithOffsetMapRequest,
            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::<BlockOpenSessionWithOffsetMapRequest>(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 + 4, depth)?;
            self.2.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for BlockOpenSessionWithOffsetMapRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                session: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<SessionMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                offset_map: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<OffsetMapMarker>>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                initial_mappings: fidl::new_empty!(
                    fidl::encoding::Optional<fidl::encoding::Vector<BlockOffsetMapping, 64>>,
                    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::Endpoint<fidl::endpoints::ServerEnd<SessionMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.session,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<OffsetMapMarker>>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.offset_map,
                decoder,
                offset + 4,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Optional<fidl::encoding::Vector<BlockOffsetMapping, 64>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.initial_mappings,
                decoder,
                offset + 8,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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