fidl_fuchsia_storage_block/

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct BlockConnectMapperRequest {
    pub server_end: fidl::endpoints::ServerEnd<MapperMarker>,
}

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

#[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 BlockOpenSessionWithOptionsRequest {
    pub session: fidl::endpoints::ServerEnd<SessionMarker>,
    pub mappings: Vec<BlockOffsetMapping>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MapperOpenSessionRequest {
    pub session: fidl::endpoints::ServerEnd<MapperSessionMarker>,
    /// VMO that contains the mappings.
    pub mapping_vmo: fidl::Vmo,
    /// Page requests will be delivered on the port.
    pub port: Option<fidl::Port>,
    /// Completed requests are delivered on this queue.
    pub delivery_queue: Option<fidl::Vmo>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MapperSessionOpenChildSessionRequest {
    pub session: fidl::endpoints::ServerEnd<MapperSessionMarker>,
    /// VMO that contains the mappings.
    pub mapping_vmo: fidl::Vmo,
    /// Key in the parent session identifying the parent mapping to route through.
    pub parent_key: u64,
    /// Page requests will be delivered on the port.
    pub port: Option<fidl::Port>,
    /// Completed requests are delivered on this queue.
    pub delivery_queue: Option<fidl::Vmo>,
}

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

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

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

#[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 = "fuchsia.storage.block.Block";
}
impl fidl::endpoints::DiscoverableProtocolMarker for BlockMarker {}
pub type BlockGetInfoResult = Result<BlockInfo, i32>;
pub type BlockConnectMapperResult = Result<(), i32>;
pub type BlockGetMetadataResult = Result<PartitionInfo, i32>;

pub trait BlockProxyInterface: Send + Sync {
    type GetInfoResponseFut: std::future::Future<Output = Result<BlockGetInfoResult, fidl::Error>>
        + Send;
    fn r#get_info(&self) -> Self::GetInfoResponseFut;
    fn r#open_session(
        &self,
        session: fidl::endpoints::ServerEnd<SessionMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#open_session_with_options(
        &self,
        session: fidl::endpoints::ServerEnd<SessionMarker>,
        mappings: &[BlockOffsetMapping],
    ) -> Result<(), fidl::Error>;
    type ConnectMapperResponseFut: std::future::Future<Output = Result<BlockConnectMapperResult, fidl::Error>>
        + Send;
    fn r#connect_mapper(
        &self,
        server_end: fidl::endpoints::ServerEnd<MapperMarker>,
    ) -> Self::ConnectMapperResponseFut;
    type GetTypeGuidResponseFut: std::future::Future<Output = Result<(i32, Option<Box<Guid>>), fidl::Error>>
        + Send;
    fn r#get_type_guid(&self) -> Self::GetTypeGuidResponseFut;
    type GetInstanceGuidResponseFut: std::future::Future<Output = Result<(i32, Option<Box<Guid>>), fidl::Error>>
        + Send;
    fn r#get_instance_guid(&self) -> Self::GetInstanceGuidResponseFut;
    type GetNameResponseFut: std::future::Future<Output = Result<(i32, Option<String>), fidl::Error>>
        + Send;
    fn r#get_name(&self) -> Self::GetNameResponseFut;
    type GetMetadataResponseFut: std::future::Future<Output = Result<BlockGetMetadataResult, fidl::Error>>
        + Send;
    fn r#get_metadata(&self) -> Self::GetMetadataResponseFut;
    type QuerySlicesResponseFut: std::future::Future<Output = Result<(i32, [VsliceRange; 16], u64), fidl::Error>>
        + Send;
    fn r#query_slices(&self, start_slices: &[u64]) -> Self::QuerySlicesResponseFut;
    type GetVolumeInfoResponseFut: std::future::Future<
            Output = Result<
                (i32, Option<Box<VolumeManagerInfo>>, Option<Box<VolumeInfo>>),
                fidl::Error,
            >,
        > + Send;
    fn r#get_volume_info(&self) -> Self::GetVolumeInfoResponseFut;
    type ExtendResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#extend(&self, start_slice: u64, slice_count: u64) -> Self::ExtendResponseFut;
    type ShrinkResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#shrink(&self, start_slice: u64, slice_count: u64) -> Self::ShrinkResponseFut;
    type DestroyResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#destroy(&self) -> Self::DestroyResponseFut;
}
#[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 {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

    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::<BlockMarker>(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>,
            BlockMarker,
        >(
            (),
            0x58777a4a31cc9a47,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.info))
    }

    /// 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,),
            0x2ca32f8c64f1d6c8,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Opens a new FIFO-based session on the block device, with additional options.
    ///
    /// # Mappings
    ///
    /// The `mappings` argument is a list of logical -> physical block mappings, which the server
    /// will transparently apply to device offsets in block FIFO requests within this session.
    /// The mappings are logically contiguous starting from logical offset 0.
    ///
    /// 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
    /// OpenSessionWithOptions on the underlying block device, providing mappings which translate
    /// block offsets which are relative to (and bounded by) the partition to absolute offsets on
    /// the device.
    ///
    /// Mappings can only ever restrict the visible range of a device; servers will reject mappings
    /// which exceed the range of the device.
    ///
    /// If `mappings` is empty, the session channel will be closed with epitaph
    /// `ZX_ERR_INVALID_ARGS`.
    pub fn r#open_session_with_options(
        &self,
        mut session: fidl::endpoints::ServerEnd<SessionMarker>,
        mut mappings: &[BlockOffsetMapping],
    ) -> Result<(), fidl::Error> {
        self.client.send::<BlockOpenSessionWithOptionsRequest>(
            (session, mappings),
            0x1974e5f7b9de6f0c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Connects to the device's Mapper protocol, allowing read-only mapped page-in.
    /// Since the caller already holds a handle to Block (which grants full read/write access
    /// to the device), this method provides a direct way to obtain the corresponding Mapper
    /// protocol without requiring an out-of-band channel or separate capability routing.
    ///
    /// If the device or driver does not support the Mapper protocol, ZX_ERR_NOT_SUPPORTED
    /// is returned.
    pub fn r#connect_mapper(
        &self,
        mut server_end: fidl::endpoints::ServerEnd<MapperMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BlockConnectMapperResult, fidl::Error> {
        let _response = self.client.send_query::<
            BlockConnectMapperRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            BlockMarker,
        >(
            (server_end,),
            0xa38a3fbbe3412c3,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Gets the type GUID of the partition (if one exists).
    /// If the partition has no type GUID, ZX_ERR_NOT_SUPPORTED is returned.
    pub fn r#get_type_guid(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(i32, Option<Box<Guid>>), fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, BlockGetTypeGuidResponse, BlockMarker>(
                (),
                0xefe4e41dafce4cc,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok((_response.status, _response.guid))
    }

    /// Gets the instance GUID of the partition (if one exists).
    /// If the partition has no instance GUID, ZX_ERR_NOT_SUPPORTED is returned.
    pub fn r#get_instance_guid(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(i32, Option<Box<Guid>>), fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, BlockGetInstanceGuidResponse, BlockMarker>(
                (),
                0x2e85011aabeb87fb,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok((_response.status, _response.guid))
    }

    /// Gets the name of the partition (if one exists).
    /// If the partition has no name, ZX_ERR_NOT_SUPPORTED is returned.
    pub fn r#get_name(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(i32, Option<String>), fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, BlockGetNameResponse, BlockMarker>(
                (),
                0x630be18badedbb05,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok((_response.status, _response.name))
    }

    /// Gets the metadata for the partition.
    ///
    /// Fields may be absent if the partition doesn't have the given metadata.
    pub fn r#get_metadata(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BlockGetMetadataResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<PartitionInfo, i32>,
            BlockMarker,
        >(
            (),
            0x2c76b02ef9382533,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Returns the number of contiguous allocated (or unallocated) vslices
    /// starting from each vslice.
    ///
    /// Returns ZX_ERR_NOT_SUPPORTED if the device is not a volume.
    pub fn r#query_slices(
        &self,
        mut start_slices: &[u64],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(i32, [VsliceRange; 16], u64), fidl::Error> {
        let _response = self
            .client
            .send_query::<BlockQuerySlicesRequest, BlockQuerySlicesResponse, BlockMarker>(
                (start_slices,),
                0x289240ac4fbaa190,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok((_response.status, _response.response, _response.response_count))
    }

    /// Returns the information about this volume and the volume manager it is embedded in.
    ///
    /// Returns ZX_ERR_NOT_SUPPORTED if the device is not a volume.
    pub fn r#get_volume_info(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(i32, Option<Box<VolumeManagerInfo>>, Option<Box<VolumeInfo>>), fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, BlockGetVolumeInfoResponse, BlockMarker>(
                (),
                0x3a7dc69ea5d788d4,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok((_response.status, _response.manager, _response.volume))
    }

    /// Extends the mapping of this partition.
    ///
    /// The ability to extend the partition is dependent on having sufficient free space on the
    /// underlying device, having sufficient free slots for tracking the bytes in the volume
    /// manager header, and the partition limit (see VolumeManager.SetPartitionLimit).
    ///
    /// Returns ZX_ERR_NOT_SUPPORTED if the device is not a volume.
    pub fn r#extend(
        &self,
        mut start_slice: u64,
        mut slice_count: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<i32, fidl::Error> {
        let _response =
            self.client.send_query::<BlockExtendRequest, BlockExtendResponse, BlockMarker>(
                (start_slice, slice_count),
                0x273fb2980ff24157,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.status)
    }

    /// Shrinks a virtual partition. Returns `ZX_OK` if ANY slices are
    /// freed, even if part of the requested range contains unallocated slices.
    ///
    /// Returns ZX_ERR_NOT_SUPPORTED if the device is not a volume.
    pub fn r#shrink(
        &self,
        mut start_slice: u64,
        mut slice_count: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<i32, fidl::Error> {
        let _response =
            self.client.send_query::<BlockShrinkRequest, BlockShrinkResponse, BlockMarker>(
                (start_slice, slice_count),
                0x73da6de865600a8b,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.status)
    }

    /// Destroys the current volume, removing it from the VolumeManager, and
    /// freeing all underlying storage. The connection to the volume is also closed.
    ///
    /// Returns ZX_ERR_NOT_SUPPORTED if the device is not a volume.
    pub fn r#destroy(&self, ___deadline: zx::MonotonicInstant) -> Result<i32, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, BlockDestroyResponse, BlockMarker>(
                (),
                0x5866ba764e05a68e,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.status)
    }
}

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

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

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

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

#[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.storage.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)
    }

    /// 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, with additional options.
    ///
    /// # Mappings
    ///
    /// The `mappings` argument is a list of logical -> physical block mappings, which the server
    /// will transparently apply to device offsets in block FIFO requests within this session.
    /// The mappings are logically contiguous starting from logical offset 0.
    ///
    /// 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
    /// OpenSessionWithOptions on the underlying block device, providing mappings which translate
    /// block offsets which are relative to (and bounded by) the partition to absolute offsets on
    /// the device.
    ///
    /// Mappings can only ever restrict the visible range of a device; servers will reject mappings
    /// which exceed the range of the device.
    ///
    /// If `mappings` is empty, the session channel will be closed with epitaph
    /// `ZX_ERR_INVALID_ARGS`.
    pub fn r#open_session_with_options(
        &self,
        mut session: fidl::endpoints::ServerEnd<SessionMarker>,
        mut mappings: &[BlockOffsetMapping],
    ) -> Result<(), fidl::Error> {
        BlockProxyInterface::r#open_session_with_options(self, session, mappings)
    }

    /// Connects to the device's Mapper protocol, allowing read-only mapped page-in.
    /// Since the caller already holds a handle to Block (which grants full read/write access
    /// to the device), this method provides a direct way to obtain the corresponding Mapper
    /// protocol without requiring an out-of-band channel or separate capability routing.
    ///
    /// If the device or driver does not support the Mapper protocol, ZX_ERR_NOT_SUPPORTED
    /// is returned.
    pub fn r#connect_mapper(
        &self,
        mut server_end: fidl::endpoints::ServerEnd<MapperMarker>,
    ) -> fidl::client::QueryResponseFut<
        BlockConnectMapperResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BlockProxyInterface::r#connect_mapper(self, server_end)
    }

    /// Gets the type GUID of the partition (if one exists).
    /// If the partition has no type GUID, ZX_ERR_NOT_SUPPORTED is returned.
    pub fn r#get_type_guid(
        &self,
    ) -> fidl::client::QueryResponseFut<
        (i32, Option<Box<Guid>>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BlockProxyInterface::r#get_type_guid(self)
    }

    /// Gets the instance GUID of the partition (if one exists).
    /// If the partition has no instance GUID, ZX_ERR_NOT_SUPPORTED is returned.
    pub fn r#get_instance_guid(
        &self,
    ) -> fidl::client::QueryResponseFut<
        (i32, Option<Box<Guid>>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BlockProxyInterface::r#get_instance_guid(self)
    }

    /// Gets the name of the partition (if one exists).
    /// If the partition has no name, ZX_ERR_NOT_SUPPORTED is returned.
    pub fn r#get_name(
        &self,
    ) -> fidl::client::QueryResponseFut<
        (i32, Option<String>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BlockProxyInterface::r#get_name(self)
    }

    /// Gets the metadata for the partition.
    ///
    /// Fields may be absent if the partition doesn't have the given metadata.
    pub fn r#get_metadata(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BlockGetMetadataResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BlockProxyInterface::r#get_metadata(self)
    }

    /// Returns the number of contiguous allocated (or unallocated) vslices
    /// starting from each vslice.
    ///
    /// Returns ZX_ERR_NOT_SUPPORTED if the device is not a volume.
    pub fn r#query_slices(
        &self,
        mut start_slices: &[u64],
    ) -> fidl::client::QueryResponseFut<
        (i32, [VsliceRange; 16], u64),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BlockProxyInterface::r#query_slices(self, start_slices)
    }

    /// Returns the information about this volume and the volume manager it is embedded in.
    ///
    /// Returns ZX_ERR_NOT_SUPPORTED if the device is not a volume.
    pub fn r#get_volume_info(
        &self,
    ) -> fidl::client::QueryResponseFut<
        (i32, Option<Box<VolumeManagerInfo>>, Option<Box<VolumeInfo>>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BlockProxyInterface::r#get_volume_info(self)
    }

    /// Extends the mapping of this partition.
    ///
    /// The ability to extend the partition is dependent on having sufficient free space on the
    /// underlying device, having sufficient free slots for tracking the bytes in the volume
    /// manager header, and the partition limit (see VolumeManager.SetPartitionLimit).
    ///
    /// Returns ZX_ERR_NOT_SUPPORTED if the device is not a volume.
    pub fn r#extend(
        &self,
        mut start_slice: u64,
        mut slice_count: u64,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        BlockProxyInterface::r#extend(self, start_slice, slice_count)
    }

    /// Shrinks a virtual partition. Returns `ZX_OK` if ANY slices are
    /// freed, even if part of the requested range contains unallocated slices.
    ///
    /// Returns ZX_ERR_NOT_SUPPORTED if the device is not a volume.
    pub fn r#shrink(
        &self,
        mut start_slice: u64,
        mut slice_count: u64,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        BlockProxyInterface::r#shrink(self, start_slice, slice_count)
    }

    /// Destroys the current volume, removing it from the VolumeManager, and
    /// freeing all underlying storage. The connection to the volume is also closed.
    ///
    /// Returns ZX_ERR_NOT_SUPPORTED if the device is not a volume.
    pub fn r#destroy(
        &self,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        BlockProxyInterface::r#destroy(self)
    }
}

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,
                0x58777a4a31cc9a47,
            >(_buf?)?;
            Ok(_response.map(|x| x.info))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, BlockGetInfoResult>(
            (),
            0x58777a4a31cc9a47,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

    fn r#open_session_with_options(
        &self,
        mut session: fidl::endpoints::ServerEnd<SessionMarker>,
        mut mappings: &[BlockOffsetMapping],
    ) -> Result<(), fidl::Error> {
        self.client.send::<BlockOpenSessionWithOptionsRequest>(
            (session, mappings),
            0x1974e5f7b9de6f0c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type ConnectMapperResponseFut = fidl::client::QueryResponseFut<
        BlockConnectMapperResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#connect_mapper(
        &self,
        mut server_end: fidl::endpoints::ServerEnd<MapperMarker>,
    ) -> Self::ConnectMapperResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BlockConnectMapperResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xa38a3fbbe3412c3,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<BlockConnectMapperRequest, BlockConnectMapperResult>(
            (server_end,),
            0xa38a3fbbe3412c3,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetTypeGuidResponseFut = fidl::client::QueryResponseFut<
        (i32, Option<Box<Guid>>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_type_guid(&self) -> Self::GetTypeGuidResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, Option<Box<Guid>>), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                BlockGetTypeGuidResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xefe4e41dafce4cc,
            >(_buf?)?;
            Ok((_response.status, _response.guid))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, (i32, Option<Box<Guid>>)>(
            (),
            0xefe4e41dafce4cc,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetInstanceGuidResponseFut = fidl::client::QueryResponseFut<
        (i32, Option<Box<Guid>>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_instance_guid(&self) -> Self::GetInstanceGuidResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, Option<Box<Guid>>), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                BlockGetInstanceGuidResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2e85011aabeb87fb,
            >(_buf?)?;
            Ok((_response.status, _response.guid))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, (i32, Option<Box<Guid>>)>(
            (),
            0x2e85011aabeb87fb,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

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

    type QuerySlicesResponseFut = fidl::client::QueryResponseFut<
        (i32, [VsliceRange; 16], u64),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#query_slices(&self, mut start_slices: &[u64]) -> Self::QuerySlicesResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, [VsliceRange; 16], u64), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                BlockQuerySlicesResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x289240ac4fbaa190,
            >(_buf?)?;
            Ok((_response.status, _response.response, _response.response_count))
        }
        self.client.send_query_and_decode::<BlockQuerySlicesRequest, (i32, [VsliceRange; 16], u64)>(
            (start_slices,),
            0x289240ac4fbaa190,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetVolumeInfoResponseFut = fidl::client::QueryResponseFut<
        (i32, Option<Box<VolumeManagerInfo>>, Option<Box<VolumeInfo>>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_volume_info(&self) -> Self::GetVolumeInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, Option<Box<VolumeManagerInfo>>, Option<Box<VolumeInfo>>), fidl::Error>
        {
            let _response = fidl::client::decode_transaction_body::<
                BlockGetVolumeInfoResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3a7dc69ea5d788d4,
            >(_buf?)?;
            Ok((_response.status, _response.manager, _response.volume))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            (i32, Option<Box<VolumeManagerInfo>>, Option<Box<VolumeInfo>>),
        >(
            (),
            0x3a7dc69ea5d788d4,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ExtendResponseFut =
        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#extend(&self, mut start_slice: u64, mut slice_count: u64) -> Self::ExtendResponseFut {
        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::<
                BlockExtendResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x273fb2980ff24157,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<BlockExtendRequest, i32>(
            (start_slice, slice_count),
            0x273fb2980ff24157,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ShrinkResponseFut =
        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#shrink(&self, mut start_slice: u64, mut slice_count: u64) -> Self::ShrinkResponseFut {
        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::<
                BlockShrinkResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x73da6de865600a8b,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<BlockShrinkRequest, i32>(
            (start_slice, slice_count),
            0x73da6de865600a8b,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

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.storage.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 {
                    0x58777a4a31cc9a47 => {
                        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,
                            },
                        })
                    }
                    0x2ca32f8c64f1d6c8 => {
                        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 })
                    }
                    0x1974e5f7b9de6f0c => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            BlockOpenSessionWithOptionsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BlockOpenSessionWithOptionsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BlockControlHandle { inner: this.inner.clone() };
                        Ok(BlockRequest::OpenSessionWithOptions {
                            session: req.session,
                            mappings: req.mappings,

                            control_handle,
                        })
                    }
                    0xa38a3fbbe3412c3 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BlockConnectMapperRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BlockConnectMapperRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BlockControlHandle { inner: this.inner.clone() };
                        Ok(BlockRequest::ConnectMapper {
                            server_end: req.server_end,

                            responder: BlockConnectMapperResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0xefe4e41dafce4cc => {
                        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::GetTypeGuid {
                            responder: BlockGetTypeGuidResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2e85011aabeb87fb => {
                        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::GetInstanceGuid {
                            responder: BlockGetInstanceGuidResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x630be18badedbb05 => {
                        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::GetName {
                            responder: BlockGetNameResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2c76b02ef9382533 => {
                        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::GetMetadata {
                            responder: BlockGetMetadataResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x289240ac4fbaa190 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BlockQuerySlicesRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BlockQuerySlicesRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BlockControlHandle { inner: this.inner.clone() };
                        Ok(BlockRequest::QuerySlices {
                            start_slices: req.start_slices,

                            responder: BlockQuerySlicesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3a7dc69ea5d788d4 => {
                        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::GetVolumeInfo {
                            responder: BlockGetVolumeInfoResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x273fb2980ff24157 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BlockExtendRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BlockExtendRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BlockControlHandle { inner: this.inner.clone() };
                        Ok(BlockRequest::Extend {
                            start_slice: req.start_slice,
                            slice_count: req.slice_count,

                            responder: BlockExtendResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x73da6de865600a8b => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BlockShrinkRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BlockShrinkRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BlockControlHandle { inner: this.inner.clone() };
                        Ok(BlockRequest::Shrink {
                            start_slice: req.start_slice,
                            slice_count: req.slice_count,

                            responder: BlockShrinkResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5866ba764e05a68e => {
                        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::Destroy {
                            responder: BlockDestroyResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => 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 },
    /// 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, with additional options.
    ///
    /// # Mappings
    ///
    /// The `mappings` argument is a list of logical -> physical block mappings, which the server
    /// will transparently apply to device offsets in block FIFO requests within this session.
    /// The mappings are logically contiguous starting from logical offset 0.
    ///
    /// 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
    /// OpenSessionWithOptions on the underlying block device, providing mappings which translate
    /// block offsets which are relative to (and bounded by) the partition to absolute offsets on
    /// the device.
    ///
    /// Mappings can only ever restrict the visible range of a device; servers will reject mappings
    /// which exceed the range of the device.
    ///
    /// If `mappings` is empty, the session channel will be closed with epitaph
    /// `ZX_ERR_INVALID_ARGS`.
    OpenSessionWithOptions {
        session: fidl::endpoints::ServerEnd<SessionMarker>,
        mappings: Vec<BlockOffsetMapping>,
        control_handle: BlockControlHandle,
    },
    /// Connects to the device's Mapper protocol, allowing read-only mapped page-in.
    /// Since the caller already holds a handle to Block (which grants full read/write access
    /// to the device), this method provides a direct way to obtain the corresponding Mapper
    /// protocol without requiring an out-of-band channel or separate capability routing.
    ///
    /// If the device or driver does not support the Mapper protocol, ZX_ERR_NOT_SUPPORTED
    /// is returned.
    ConnectMapper {
        server_end: fidl::endpoints::ServerEnd<MapperMarker>,
        responder: BlockConnectMapperResponder,
    },
    /// Gets the type GUID of the partition (if one exists).
    /// If the partition has no type GUID, ZX_ERR_NOT_SUPPORTED is returned.
    GetTypeGuid { responder: BlockGetTypeGuidResponder },
    /// Gets the instance GUID of the partition (if one exists).
    /// If the partition has no instance GUID, ZX_ERR_NOT_SUPPORTED is returned.
    GetInstanceGuid { responder: BlockGetInstanceGuidResponder },
    /// Gets the name of the partition (if one exists).
    /// If the partition has no name, ZX_ERR_NOT_SUPPORTED is returned.
    GetName { responder: BlockGetNameResponder },
    /// Gets the metadata for the partition.
    ///
    /// Fields may be absent if the partition doesn't have the given metadata.
    GetMetadata { responder: BlockGetMetadataResponder },
    /// Returns the number of contiguous allocated (or unallocated) vslices
    /// starting from each vslice.
    ///
    /// Returns ZX_ERR_NOT_SUPPORTED if the device is not a volume.
    QuerySlices { start_slices: Vec<u64>, responder: BlockQuerySlicesResponder },
    /// Returns the information about this volume and the volume manager it is embedded in.
    ///
    /// Returns ZX_ERR_NOT_SUPPORTED if the device is not a volume.
    GetVolumeInfo { responder: BlockGetVolumeInfoResponder },
    /// Extends the mapping of this partition.
    ///
    /// The ability to extend the partition is dependent on having sufficient free space on the
    /// underlying device, having sufficient free slots for tracking the bytes in the volume
    /// manager header, and the partition limit (see VolumeManager.SetPartitionLimit).
    ///
    /// Returns ZX_ERR_NOT_SUPPORTED if the device is not a volume.
    Extend { start_slice: u64, slice_count: u64, responder: BlockExtendResponder },
    /// Shrinks a virtual partition. Returns `ZX_OK` if ANY slices are
    /// freed, even if part of the requested range contains unallocated slices.
    ///
    /// Returns ZX_ERR_NOT_SUPPORTED if the device is not a volume.
    Shrink { start_slice: u64, slice_count: u64, responder: BlockShrinkResponder },
    /// Destroys the current volume, removing it from the VolumeManager, and
    /// freeing all underlying storage. The connection to the volume is also closed.
    ///
    /// Returns ZX_ERR_NOT_SUPPORTED if the device is not a volume.
    Destroy { responder: BlockDestroyResponder },
}

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_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_options(
        self,
    ) -> Option<(
        fidl::endpoints::ServerEnd<SessionMarker>,
        Vec<BlockOffsetMapping>,
        BlockControlHandle,
    )> {
        if let BlockRequest::OpenSessionWithOptions { session, mappings, control_handle } = self {
            Some((session, mappings, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_connect_mapper(
        self,
    ) -> Option<(fidl::endpoints::ServerEnd<MapperMarker>, BlockConnectMapperResponder)> {
        if let BlockRequest::ConnectMapper { server_end, responder } = self {
            Some((server_end, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_type_guid(self) -> Option<(BlockGetTypeGuidResponder)> {
        if let BlockRequest::GetTypeGuid { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_instance_guid(self) -> Option<(BlockGetInstanceGuidResponder)> {
        if let BlockRequest::GetInstanceGuid { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_name(self) -> Option<(BlockGetNameResponder)> {
        if let BlockRequest::GetName { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_metadata(self) -> Option<(BlockGetMetadataResponder)> {
        if let BlockRequest::GetMetadata { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_query_slices(self) -> Option<(Vec<u64>, BlockQuerySlicesResponder)> {
        if let BlockRequest::QuerySlices { start_slices, responder } = self {
            Some((start_slices, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_volume_info(self) -> Option<(BlockGetVolumeInfoResponder)> {
        if let BlockRequest::GetVolumeInfo { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_extend(self) -> Option<(u64, u64, BlockExtendResponder)> {
        if let BlockRequest::Extend { start_slice, slice_count, responder } = self {
            Some((start_slice, slice_count, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_shrink(self) -> Option<(u64, u64, BlockShrinkResponder)> {
        if let BlockRequest::Shrink { start_slice, slice_count, responder } = self {
            Some((start_slice, slice_count, responder))
        } else {
            None
        }
    }

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

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            BlockRequest::GetInfo { .. } => "get_info",
            BlockRequest::OpenSession { .. } => "open_session",
            BlockRequest::OpenSessionWithOptions { .. } => "open_session_with_options",
            BlockRequest::ConnectMapper { .. } => "connect_mapper",
            BlockRequest::GetTypeGuid { .. } => "get_type_guid",
            BlockRequest::GetInstanceGuid { .. } => "get_instance_guid",
            BlockRequest::GetName { .. } => "get_name",
            BlockRequest::GetMetadata { .. } => "get_metadata",
            BlockRequest::QuerySlices { .. } => "query_slices",
            BlockRequest::GetVolumeInfo { .. } => "get_volume_info",
            BlockRequest::Extend { .. } => "extend",
            BlockRequest::Shrink { .. } => "shrink",
            BlockRequest::Destroy { .. } => "destroy",
        }
    }
}

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

impl BlockControlHandle {
    pub fn shutdown_with_epitaph(&self, status: impl Into<fidl::Epitaph>) {
        self.inner.shutdown_with_epitaph(status.into())
    }
}

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

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        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,
            0x58777a4a31cc9a47,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BlockConnectMapperResponder {
    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 BlockConnectMapperResponder {
    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 BlockConnectMapperResponder {
    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 BlockConnectMapperResponder {
    /// 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,
                0xa38a3fbbe3412c3,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

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

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

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

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

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

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

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

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

    fn send_raw(
        &self,
        mut status: i32,
        mut response: &[VsliceRange; 16],
        mut response_count: u64,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<BlockQuerySlicesResponse>(
            (status, response, response_count),
            self.tx_id,
            0x289240ac4fbaa190,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

    fn send_raw(
        &self,
        mut status: i32,
        mut manager: Option<&VolumeManagerInfo>,
        mut volume: Option<&VolumeInfo>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<BlockGetVolumeInfoResponse>(
            (status, manager, volume),
            self.tx_id,
            0x3a7dc69ea5d788d4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BlockExtendResponder {
    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 BlockExtendResponder {
    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 BlockExtendResponder {
    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 BlockExtendResponder {
    /// 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::<BlockExtendResponse>(
            (status,),
            self.tx_id,
            0x273fb2980ff24157,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BlockShrinkResponder {
    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 BlockShrinkResponder {
    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 BlockShrinkResponder {
    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 BlockShrinkResponder {
    /// 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::<BlockShrinkResponse>(
            (status,),
            self.tx_id,
            0x73da6de865600a8b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BlockDestroyResponder {
    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 BlockDestroyResponder {
    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 BlockDestroyResponder {
    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 BlockDestroyResponder {
    /// 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::<BlockDestroyResponse>(
            (status,),
            self.tx_id,
            0x5866ba764e05a68e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for MapperMarker {
    type Proxy = MapperProxy;
    type RequestStream = MapperRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = MapperSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.storage.block.Mapper";
}
impl fidl::endpoints::DiscoverableProtocolMarker for MapperMarker {}
pub type MapperOpenSessionResult = Result<(), i32>;

pub trait MapperProxyInterface: Send + Sync {
    type OpenSessionResponseFut: std::future::Future<Output = Result<MapperOpenSessionResult, fidl::Error>>
        + Send;
    fn r#open_session(
        &self,
        session: fidl::endpoints::ServerEnd<MapperSessionMarker>,
        mapping_vmo: fidl::Vmo,
        port: Option<fidl::Port>,
        delivery_queue: Option<fidl::Vmo>,
    ) -> Self::OpenSessionResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct MapperSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for MapperSynchronousProxy {
    type Proxy = MapperProxy;
    type Protocol = MapperMarker;

    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 MapperSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

    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<MapperEvent, fidl::Error> {
        MapperEvent::decode(self.client.wait_for_event::<MapperMarker>(deadline)?)
    }

    /// Bootstraps the driver mapper with the mapping VMO and verifier handles.
    pub fn r#open_session(
        &self,
        mut session: fidl::endpoints::ServerEnd<MapperSessionMarker>,
        mut mapping_vmo: fidl::Vmo,
        mut port: Option<fidl::Port>,
        mut delivery_queue: Option<fidl::Vmo>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<MapperOpenSessionResult, fidl::Error> {
        let _response = self.client.send_query::<
            MapperOpenSessionRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
            MapperMarker,
        >(
            (session, mapping_vmo, port, delivery_queue,),
            0x638c49dbdff13a9c,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<MapperMarker>("open_session")?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for MapperProxy {
    type Protocol = MapperMarker;

    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 MapperProxy {
    /// Create a new Proxy for fuchsia.storage.block/Mapper.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <MapperMarker 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) -> MapperEventStream {
        MapperEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Bootstraps the driver mapper with the mapping VMO and verifier handles.
    pub fn r#open_session(
        &self,
        mut session: fidl::endpoints::ServerEnd<MapperSessionMarker>,
        mut mapping_vmo: fidl::Vmo,
        mut port: Option<fidl::Port>,
        mut delivery_queue: Option<fidl::Vmo>,
    ) -> fidl::client::QueryResponseFut<
        MapperOpenSessionResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        MapperProxyInterface::r#open_session(self, session, mapping_vmo, port, delivery_queue)
    }
}

impl MapperProxyInterface for MapperProxy {
    type OpenSessionResponseFut = fidl::client::QueryResponseFut<
        MapperOpenSessionResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#open_session(
        &self,
        mut session: fidl::endpoints::ServerEnd<MapperSessionMarker>,
        mut mapping_vmo: fidl::Vmo,
        mut port: Option<fidl::Port>,
        mut delivery_queue: Option<fidl::Vmo>,
    ) -> Self::OpenSessionResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<MapperOpenSessionResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x638c49dbdff13a9c,
            >(_buf?)?
            .into_result::<MapperMarker>("open_session")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<MapperOpenSessionRequest, MapperOpenSessionResult>(
            (session, mapping_vmo, port, delivery_queue),
            0x638c49dbdff13a9c,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for MapperRequestStream {
    type Protocol = MapperMarker;
    type ControlHandle = MapperControlHandle;

    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 {
        MapperControlHandle { 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 MapperRequestStream {
    type Item = Result<MapperRequest, 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 MapperRequestStream 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 {
                    0x638c49dbdff13a9c => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            MapperOpenSessionRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MapperOpenSessionRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = MapperControlHandle { inner: this.inner.clone() };
                        Ok(MapperRequest::OpenSession {
                            session: req.session,
                            mapping_vmo: req.mapping_vmo,
                            port: req.port,
                            delivery_queue: req.delivery_queue,

                            responder: MapperOpenSessionResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ if header.tx_id == 0
                        && header
                            .dynamic_flags()
                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        Ok(MapperRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: MapperControlHandle { inner: this.inner.clone() },
                            method_type: fidl::MethodType::OneWay,
                        })
                    }
                    _ if header
                        .dynamic_flags()
                        .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        this.inner.send_framework_err(
                            fidl::encoding::FrameworkErr::UnknownMethod,
                            header.tx_id,
                            header.ordinal,
                            header.dynamic_flags(),
                            (bytes, handles),
                        )?;
                        Ok(MapperRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: MapperControlHandle { inner: this.inner.clone() },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <MapperMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Exposed by the block driver, routed via fshost to pkg-cache.
#[derive(Debug)]
pub enum MapperRequest {
    /// Bootstraps the driver mapper with the mapping VMO and verifier handles.
    OpenSession {
        session: fidl::endpoints::ServerEnd<MapperSessionMarker>,
        mapping_vmo: fidl::Vmo,
        port: Option<fidl::Port>,
        delivery_queue: Option<fidl::Vmo>,
        responder: MapperOpenSessionResponder,
    },
    /// An interaction was received which does not match any known method.
    #[non_exhaustive]
    _UnknownMethod {
        /// Ordinal of the method that was called.
        ordinal: u64,
        control_handle: MapperControlHandle,
        method_type: fidl::MethodType,
    },
}

impl MapperRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_open_session(
        self,
    ) -> Option<(
        fidl::endpoints::ServerEnd<MapperSessionMarker>,
        fidl::Vmo,
        Option<fidl::Port>,
        Option<fidl::Vmo>,
        MapperOpenSessionResponder,
    )> {
        if let MapperRequest::OpenSession {
            session,
            mapping_vmo,
            port,
            delivery_queue,
            responder,
        } = self
        {
            Some((session, mapping_vmo, port, delivery_queue, responder))
        } else {
            None
        }
    }

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

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

impl MapperControlHandle {
    pub fn shutdown_with_epitaph(&self, status: impl Into<fidl::Epitaph>) {
        self.inner.shutdown_with_epitaph(status.into())
    }
}

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

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        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 MapperControlHandle {}

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

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

    fn control_handle(&self) -> &MapperControlHandle {
        &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 MapperOpenSessionResponder {
    /// 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::FlexibleResultType<
            fidl::encoding::EmptyStruct,
            i32,
        >>(
            fidl::encoding::FlexibleResult::new(result),
            self.tx_id,
            0x638c49dbdff13a9c,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for MapperSessionMarker {
    type Proxy = MapperSessionProxy;
    type RequestStream = MapperSessionRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = MapperSessionSynchronousProxy;

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

pub trait MapperSessionProxyInterface: Send + Sync {
    type CloseResponseFut: std::future::Future<
            Output = Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error>,
        > + Send;
    fn r#close(&self) -> Self::CloseResponseFut;
    type CreateVmoResponseFut: std::future::Future<Output = Result<MapperSessionCreateVmoResult, fidl::Error>>
        + Send;
    fn r#create_vmo(
        &self,
        key: u64,
        size: u64,
        options: CreateVmoOptions,
    ) -> Self::CreateVmoResponseFut;
    type OpenChildSessionResponseFut: std::future::Future<Output = Result<MapperSessionOpenChildSessionResult, fidl::Error>>
        + Send;
    fn r#open_child_session(
        &self,
        session: fidl::endpoints::ServerEnd<MapperSessionMarker>,
        mapping_vmo: fidl::Vmo,
        parent_key: u64,
        port: Option<fidl::Port>,
        delivery_queue: Option<fidl::Vmo>,
    ) -> Self::OpenChildSessionResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct MapperSessionSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for MapperSessionSynchronousProxy {
    type Proxy = MapperSessionProxy;
    type Protocol = MapperSessionMarker;

    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 MapperSessionSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

    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<MapperSessionEvent, fidl::Error> {
        MapperSessionEvent::decode(self.client.wait_for_event::<MapperSessionMarker>(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>,
            MapperSessionMarker,
        >(
            (),
            0x5ac5d459ad7f657e,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Creates a pager-backed VMO of `size` bytes associated with `key`.
    /// Page faults on this VMO are handled directly by the driver mapper.
    pub fn r#create_vmo(
        &self,
        mut key: u64,
        mut size: u64,
        mut options: CreateVmoOptions,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<MapperSessionCreateVmoResult, fidl::Error> {
        let _response = self.client.send_query::<
            MapperSessionCreateVmoRequest,
            fidl::encoding::FlexibleResultType<MapperSessionCreateVmoResponse, i32>,
            MapperSessionMarker,
        >(
            (key, size, options,),
            0x35be1bf1bd0f9e1d,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<MapperSessionMarker>("create_vmo")?;
        Ok(_response.map(|x| x.vmo))
    }

    /// Opens a child mapper session whose reads map through `parent_key` in the parent session.
    /// When a parent session is closed, all child sessions opened from it are closed as well.
    pub fn r#open_child_session(
        &self,
        mut session: fidl::endpoints::ServerEnd<MapperSessionMarker>,
        mut mapping_vmo: fidl::Vmo,
        mut parent_key: u64,
        mut port: Option<fidl::Port>,
        mut delivery_queue: Option<fidl::Vmo>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<MapperSessionOpenChildSessionResult, fidl::Error> {
        let _response = self.client.send_query::<
            MapperSessionOpenChildSessionRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
            MapperSessionMarker,
        >(
            (session, mapping_vmo, parent_key, port, delivery_queue,),
            0x7b80686acf9dcca3,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<MapperSessionMarker>("open_child_session")?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for MapperSessionProxy {
    type Protocol = MapperSessionMarker;

    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 MapperSessionProxy {
    /// Create a new Proxy for fuchsia.storage.block/MapperSession.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <MapperSessionMarker 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) -> MapperSessionEventStream {
        MapperSessionEventStream { 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,
    > {
        MapperSessionProxyInterface::r#close(self)
    }

    /// Creates a pager-backed VMO of `size` bytes associated with `key`.
    /// Page faults on this VMO are handled directly by the driver mapper.
    pub fn r#create_vmo(
        &self,
        mut key: u64,
        mut size: u64,
        mut options: CreateVmoOptions,
    ) -> fidl::client::QueryResponseFut<
        MapperSessionCreateVmoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        MapperSessionProxyInterface::r#create_vmo(self, key, size, options)
    }

    /// Opens a child mapper session whose reads map through `parent_key` in the parent session.
    /// When a parent session is closed, all child sessions opened from it are closed as well.
    pub fn r#open_child_session(
        &self,
        mut session: fidl::endpoints::ServerEnd<MapperSessionMarker>,
        mut mapping_vmo: fidl::Vmo,
        mut parent_key: u64,
        mut port: Option<fidl::Port>,
        mut delivery_queue: Option<fidl::Vmo>,
    ) -> fidl::client::QueryResponseFut<
        MapperSessionOpenChildSessionResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        MapperSessionProxyInterface::r#open_child_session(
            self,
            session,
            mapping_vmo,
            parent_key,
            port,
            delivery_queue,
        )
    }
}

impl MapperSessionProxyInterface for MapperSessionProxy {
    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 CreateVmoResponseFut = fidl::client::QueryResponseFut<
        MapperSessionCreateVmoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#create_vmo(
        &self,
        mut key: u64,
        mut size: u64,
        mut options: CreateVmoOptions,
    ) -> Self::CreateVmoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<MapperSessionCreateVmoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<MapperSessionCreateVmoResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x35be1bf1bd0f9e1d,
            >(_buf?)?
            .into_result::<MapperSessionMarker>("create_vmo")?;
            Ok(_response.map(|x| x.vmo))
        }
        self.client
            .send_query_and_decode::<MapperSessionCreateVmoRequest, MapperSessionCreateVmoResult>(
                (key, size, options),
                0x35be1bf1bd0f9e1d,
                fidl::encoding::DynamicFlags::FLEXIBLE,
                _decode,
            )
    }

    type OpenChildSessionResponseFut = fidl::client::QueryResponseFut<
        MapperSessionOpenChildSessionResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#open_child_session(
        &self,
        mut session: fidl::endpoints::ServerEnd<MapperSessionMarker>,
        mut mapping_vmo: fidl::Vmo,
        mut parent_key: u64,
        mut port: Option<fidl::Port>,
        mut delivery_queue: Option<fidl::Vmo>,
    ) -> Self::OpenChildSessionResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<MapperSessionOpenChildSessionResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7b80686acf9dcca3,
            >(_buf?)?
            .into_result::<MapperSessionMarker>("open_child_session")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            MapperSessionOpenChildSessionRequest,
            MapperSessionOpenChildSessionResult,
        >(
            (session, mapping_vmo, parent_key, port, delivery_queue,),
            0x7b80686acf9dcca3,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for MapperSessionRequestStream {
    type Protocol = MapperSessionMarker;
    type ControlHandle = MapperSessionControlHandle;

    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 {
        MapperSessionControlHandle { 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 MapperSessionRequestStream {
    type Item = Result<MapperSessionRequest, 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 MapperSessionRequestStream 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 =
                            MapperSessionControlHandle { inner: this.inner.clone() };
                        Ok(MapperSessionRequest::Close {
                            responder: MapperSessionCloseResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x35be1bf1bd0f9e1d => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            MapperSessionCreateVmoRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MapperSessionCreateVmoRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            MapperSessionControlHandle { inner: this.inner.clone() };
                        Ok(MapperSessionRequest::CreateVmo {
                            key: req.key,
                            size: req.size,
                            options: req.options,

                            responder: MapperSessionCreateVmoResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7b80686acf9dcca3 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            MapperSessionOpenChildSessionRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MapperSessionOpenChildSessionRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            MapperSessionControlHandle { inner: this.inner.clone() };
                        Ok(MapperSessionRequest::OpenChildSession {
                            session: req.session,
                            mapping_vmo: req.mapping_vmo,
                            parent_key: req.parent_key,
                            port: req.port,
                            delivery_queue: req.delivery_queue,

                            responder: MapperSessionOpenChildSessionResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ if header.tx_id == 0
                        && header
                            .dynamic_flags()
                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        Ok(MapperSessionRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: MapperSessionControlHandle {
                                inner: this.inner.clone(),
                            },
                            method_type: fidl::MethodType::OneWay,
                        })
                    }
                    _ if header
                        .dynamic_flags()
                        .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        this.inner.send_framework_err(
                            fidl::encoding::FrameworkErr::UnknownMethod,
                            header.tx_id,
                            header.ordinal,
                            header.dynamic_flags(),
                            (bytes, handles),
                        )?;
                        Ok(MapperSessionRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: MapperSessionControlHandle {
                                inner: this.inner.clone(),
                            },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <MapperSessionMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Represents an active driver mapping session.
#[derive(Debug)]
pub enum MapperSessionRequest {
    /// 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: MapperSessionCloseResponder },
    /// Creates a pager-backed VMO of `size` bytes associated with `key`.
    /// Page faults on this VMO are handled directly by the driver mapper.
    CreateVmo {
        key: u64,
        size: u64,
        options: CreateVmoOptions,
        responder: MapperSessionCreateVmoResponder,
    },
    /// Opens a child mapper session whose reads map through `parent_key` in the parent session.
    /// When a parent session is closed, all child sessions opened from it are closed as well.
    OpenChildSession {
        session: fidl::endpoints::ServerEnd<MapperSessionMarker>,
        mapping_vmo: fidl::Vmo,
        parent_key: u64,
        port: Option<fidl::Port>,
        delivery_queue: Option<fidl::Vmo>,
        responder: MapperSessionOpenChildSessionResponder,
    },
    /// An interaction was received which does not match any known method.
    #[non_exhaustive]
    _UnknownMethod {
        /// Ordinal of the method that was called.
        ordinal: u64,
        control_handle: MapperSessionControlHandle,
        method_type: fidl::MethodType,
    },
}

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_create_vmo(
        self,
    ) -> Option<(u64, u64, CreateVmoOptions, MapperSessionCreateVmoResponder)> {
        if let MapperSessionRequest::CreateVmo { key, size, options, responder } = self {
            Some((key, size, options, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_open_child_session(
        self,
    ) -> Option<(
        fidl::endpoints::ServerEnd<MapperSessionMarker>,
        fidl::Vmo,
        u64,
        Option<fidl::Port>,
        Option<fidl::Vmo>,
        MapperSessionOpenChildSessionResponder,
    )> {
        if let MapperSessionRequest::OpenChildSession {
            session,
            mapping_vmo,
            parent_key,
            port,
            delivery_queue,
            responder,
        } = self
        {
            Some((session, mapping_vmo, parent_key, port, delivery_queue, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            MapperSessionRequest::Close { .. } => "close",
            MapperSessionRequest::CreateVmo { .. } => "create_vmo",
            MapperSessionRequest::OpenChildSession { .. } => "open_child_session",
            MapperSessionRequest::_UnknownMethod {
                method_type: fidl::MethodType::OneWay, ..
            } => "unknown one-way method",
            MapperSessionRequest::_UnknownMethod {
                method_type: fidl::MethodType::TwoWay, ..
            } => "unknown two-way method",
        }
    }
}

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

impl MapperSessionControlHandle {
    pub fn shutdown_with_epitaph(&self, status: impl Into<fidl::Epitaph>) {
        self.inner.shutdown_with_epitaph(status.into())
    }
}

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

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        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 MapperSessionControlHandle {}

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

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

    fn control_handle(&self) -> &MapperSessionControlHandle {
        &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 MapperSessionCloseResponder {
    /// 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 MapperSessionCreateVmoResponder {
    control_handle: std::mem::ManuallyDrop<MapperSessionControlHandle>,
    tx_id: u32,
}

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

    fn control_handle(&self) -> &MapperSessionControlHandle {
        &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 MapperSessionCreateVmoResponder {
    /// 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::FlexibleResultType<
            MapperSessionCreateVmoResponse,
            i32,
        >>(
            fidl::encoding::FlexibleResult::new(result.map(|vmo| (vmo,))),
            self.tx_id,
            0x35be1bf1bd0f9e1d,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

    fn control_handle(&self) -> &MapperSessionControlHandle {
        &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 MapperSessionOpenChildSessionResponder {
    /// 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::FlexibleResultType<
            fidl::encoding::EmptyStruct,
            i32,
        >>(
            fidl::encoding::FlexibleResult::new(result),
            self.tx_id,
            0x7b80686acf9dcca3,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

#[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 {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

    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::<SessionMarker>(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>,
            SessionMarker,
        >(
            (),
            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>,
            SessionMarker,
        >(
            (),
            0x7a6c7610912aaa98,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.fifo))
    }

    /// Attaches a VMO to the session. Resizable VMOs are not supported and will return
    /// `ZX_ERR_INVALID_ARGS`.
    ///
    /// Returns an identifier 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>,
            SessionMarker,
        >(
            (vmo,),
            0x677a0f6fd1a370b2,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.vmoid))
    }
}

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

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

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

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

#[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.storage.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. Resizable VMOs are not supported and will return
    /// `ZX_ERR_INVALID_ARGS`.
    ///
    /// Returns an identifier 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,
                0x7a6c7610912aaa98,
            >(_buf?)?;
            Ok(_response.map(|x| x.fifo))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, SessionGetFifoResult>(
            (),
            0x7a6c7610912aaa98,
            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,
                0x677a0f6fd1a370b2,
            >(_buf?)?;
            Ok(_response.map(|x| x.vmoid))
        }
        self.client.send_query_and_decode::<SessionAttachVmoRequest, SessionAttachVmoResult>(
            (vmo,),
            0x677a0f6fd1a370b2,
            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.storage.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,
                            },
                        })
                    }
                    0x7a6c7610912aaa98 => {
                        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,
                            },
                        })
                    }
                    0x677a0f6fd1a370b2 => {
                        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. Resizable VMOs are not supported and will return
    /// `ZX_ERR_INVALID_ARGS`.
    ///
    /// Returns an identifier 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 SessionControlHandle {
    pub fn shutdown_with_epitaph(&self, status: impl Into<fidl::Epitaph>) {
        self.inner.shutdown_with_epitaph(status.into())
    }
}

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

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        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,
            0x7a6c7610912aaa98,
            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,
            0x677a0f6fd1a370b2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for VolumeManagerMarker {
    type Proxy = VolumeManagerProxy;
    type RequestStream = VolumeManagerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = VolumeManagerSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) VolumeManager";
}
pub type VolumeManagerSetPartitionNameResult = Result<(), i32>;

pub trait VolumeManagerProxyInterface: Send + Sync {
    type AllocatePartitionResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#allocate_partition(
        &self,
        slice_count: u64,
        type_: &Guid,
        instance: &Guid,
        name: &str,
        flags: u32,
    ) -> Self::AllocatePartitionResponseFut;
    type GetInfoResponseFut: std::future::Future<Output = Result<(i32, Option<Box<VolumeManagerInfo>>), fidl::Error>>
        + Send;
    fn r#get_info(&self) -> Self::GetInfoResponseFut;
    type ActivateResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#activate(&self, old_guid: &Guid, new_guid: &Guid) -> Self::ActivateResponseFut;
    type GetPartitionLimitResponseFut: std::future::Future<Output = Result<(i32, u64), fidl::Error>>
        + Send;
    fn r#get_partition_limit(&self, guid: &Guid) -> Self::GetPartitionLimitResponseFut;
    type SetPartitionLimitResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#set_partition_limit(
        &self,
        guid: &Guid,
        slice_count: u64,
    ) -> Self::SetPartitionLimitResponseFut;
    type SetPartitionNameResponseFut: std::future::Future<Output = Result<VolumeManagerSetPartitionNameResult, fidl::Error>>
        + Send;
    fn r#set_partition_name(&self, guid: &Guid, name: &str) -> Self::SetPartitionNameResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct VolumeManagerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for VolumeManagerSynchronousProxy {
    type Proxy = VolumeManagerProxy;
    type Protocol = VolumeManagerMarker;

    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 VolumeManagerSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

    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<VolumeManagerEvent, fidl::Error> {
        VolumeManagerEvent::decode(self.client.wait_for_event::<VolumeManagerMarker>(deadline)?)
    }

    /// Allocates a virtual partition with the requested features.
    ///
    /// `slice_count` is the number of slices initially allocated to the partition, at
    /// offset zero. The number of slices allocated to a new partition must be at least one.
    /// `type` and `value` indicate type and instance GUIDs for the partition, respectively.
    /// `name` indicates the name of the new partition.
    pub fn r#allocate_partition(
        &self,
        mut slice_count: u64,
        mut type_: &Guid,
        mut instance: &Guid,
        mut name: &str,
        mut flags: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<i32, fidl::Error> {
        let _response = self.client.send_query::<
            VolumeManagerAllocatePartitionRequest,
            VolumeManagerAllocatePartitionResponse,
            VolumeManagerMarker,
        >(
            (slice_count, type_, instance, name, flags,),
            0x5db528bfc287b696,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.status)
    }

    /// Gets the VolumeManagerInfo describing this instance of the `VolumeManager`.
    ///
    /// **NOTE**: GetInfo() is used to synchronize child partition device visibility with devfs.
    /// Implementations must only respond once all child partitions of `VolumeManager` have been
    /// added to devfs, to guarantee clients can safely enumerate them.
    ///
    /// See https://fxbug.dev/42077585 for more information.
    pub fn r#get_info(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(i32, Option<Box<VolumeManagerInfo>>), fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            VolumeManagerGetInfoResponse,
            VolumeManagerMarker,
        >(
            (),
            0x2611214dcca5b064,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok((_response.status, _response.info))
    }

    /// Atomically marks a vpartition (by instance GUID) as inactive, while finding
    /// another partition (by instance GUID) and marking it as active.
    ///
    /// If the "old" partition does not exist, the GUID is ignored.
    /// If the "old" partition is the same as the "new" partition, the "old"
    /// GUID is ignored.
    /// If the "new" partition does not exist, `ZX_ERR_NOT_FOUND` is returned.
    ///
    /// This function does not destroy the "old" partition, it just marks it as
    /// inactive -- to reclaim that space, the "old" partition must be explicitly
    /// destroyed.  This destruction can also occur automatically when the FVM driver
    /// is rebound (i.e., on reboot).
    ///
    /// This function may be useful for A/B updates within the FVM,
    /// since it will allow activating updated partitions.
    pub fn r#activate(
        &self,
        mut old_guid: &Guid,
        mut new_guid: &Guid,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<i32, fidl::Error> {
        let _response = self.client.send_query::<
            VolumeManagerActivateRequest,
            VolumeManagerActivateResponse,
            VolumeManagerMarker,
        >(
            (old_guid, new_guid,),
            0x182238d40c275be,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.status)
    }

    /// Retrieves the allocation limit for the partition. A return value of 0 indicates that there
    /// is no limit and the partition can be extended as long as there is available space on the
    /// device.
    ///
    /// The partition may be larger than this limit if a smaller limit was applied after the
    /// partition had already grown to the current size.
    ///
    /// Currently the partition limit is not persisted across reboots but this may change in the
    /// future.
    pub fn r#get_partition_limit(
        &self,
        mut guid: &Guid,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(i32, u64), fidl::Error> {
        let _response = self.client.send_query::<
            VolumeManagerGetPartitionLimitRequest,
            VolumeManagerGetPartitionLimitResponse,
            VolumeManagerMarker,
        >(
            (guid,),
            0x5bc9d21ea8bd52db,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok((_response.status, _response.slice_count))
    }

    /// Sets the allocation limit for the partition. Partitions can not be extended beyond their
    /// allocation limit. The partition limit will never shrink partitions so if this value is
    /// less than the current partition size, it will keep the current size but prevent further
    /// growth.
    ///
    /// The allocation limits are on the VolumeManager API rather than on the partition because
    /// they represent a higher capability level. These limits are designed to put guards on
    /// users of the block device (and hence the Volume API).
    ///
    /// Currently the partition limit is not persisted across reboots but this may change in the
    /// future.
    pub fn r#set_partition_limit(
        &self,
        mut guid: &Guid,
        mut slice_count: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<i32, fidl::Error> {
        let _response = self.client.send_query::<
            VolumeManagerSetPartitionLimitRequest,
            VolumeManagerSetPartitionLimitResponse,
            VolumeManagerMarker,
        >(
            (guid, slice_count,),
            0x3a4903076534c093,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.status)
    }

    /// Renames the specified partition. Any existing devices that include the name of the partition
    /// in their topological path might *not* reflect the name change until the next time that the
    /// device is instantiated.
    pub fn r#set_partition_name(
        &self,
        mut guid: &Guid,
        mut name: &str,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<VolumeManagerSetPartitionNameResult, fidl::Error> {
        let _response = self.client.send_query::<
            VolumeManagerSetPartitionNameRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            VolumeManagerMarker,
        >(
            (guid, name,),
            0x26afb07b9d70ff1a,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for VolumeManagerProxy {
    type Protocol = VolumeManagerMarker;

    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 VolumeManagerProxy {
    /// Create a new Proxy for fuchsia.storage.block/VolumeManager.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <VolumeManagerMarker 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) -> VolumeManagerEventStream {
        VolumeManagerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Allocates a virtual partition with the requested features.
    ///
    /// `slice_count` is the number of slices initially allocated to the partition, at
    /// offset zero. The number of slices allocated to a new partition must be at least one.
    /// `type` and `value` indicate type and instance GUIDs for the partition, respectively.
    /// `name` indicates the name of the new partition.
    pub fn r#allocate_partition(
        &self,
        mut slice_count: u64,
        mut type_: &Guid,
        mut instance: &Guid,
        mut name: &str,
        mut flags: u32,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        VolumeManagerProxyInterface::r#allocate_partition(
            self,
            slice_count,
            type_,
            instance,
            name,
            flags,
        )
    }

    /// Gets the VolumeManagerInfo describing this instance of the `VolumeManager`.
    ///
    /// **NOTE**: GetInfo() is used to synchronize child partition device visibility with devfs.
    /// Implementations must only respond once all child partitions of `VolumeManager` have been
    /// added to devfs, to guarantee clients can safely enumerate them.
    ///
    /// See https://fxbug.dev/42077585 for more information.
    pub fn r#get_info(
        &self,
    ) -> fidl::client::QueryResponseFut<
        (i32, Option<Box<VolumeManagerInfo>>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        VolumeManagerProxyInterface::r#get_info(self)
    }

    /// Atomically marks a vpartition (by instance GUID) as inactive, while finding
    /// another partition (by instance GUID) and marking it as active.
    ///
    /// If the "old" partition does not exist, the GUID is ignored.
    /// If the "old" partition is the same as the "new" partition, the "old"
    /// GUID is ignored.
    /// If the "new" partition does not exist, `ZX_ERR_NOT_FOUND` is returned.
    ///
    /// This function does not destroy the "old" partition, it just marks it as
    /// inactive -- to reclaim that space, the "old" partition must be explicitly
    /// destroyed.  This destruction can also occur automatically when the FVM driver
    /// is rebound (i.e., on reboot).
    ///
    /// This function may be useful for A/B updates within the FVM,
    /// since it will allow activating updated partitions.
    pub fn r#activate(
        &self,
        mut old_guid: &Guid,
        mut new_guid: &Guid,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        VolumeManagerProxyInterface::r#activate(self, old_guid, new_guid)
    }

    /// Retrieves the allocation limit for the partition. A return value of 0 indicates that there
    /// is no limit and the partition can be extended as long as there is available space on the
    /// device.
    ///
    /// The partition may be larger than this limit if a smaller limit was applied after the
    /// partition had already grown to the current size.
    ///
    /// Currently the partition limit is not persisted across reboots but this may change in the
    /// future.
    pub fn r#get_partition_limit(
        &self,
        mut guid: &Guid,
    ) -> fidl::client::QueryResponseFut<(i32, u64), fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        VolumeManagerProxyInterface::r#get_partition_limit(self, guid)
    }

    /// Sets the allocation limit for the partition. Partitions can not be extended beyond their
    /// allocation limit. The partition limit will never shrink partitions so if this value is
    /// less than the current partition size, it will keep the current size but prevent further
    /// growth.
    ///
    /// The allocation limits are on the VolumeManager API rather than on the partition because
    /// they represent a higher capability level. These limits are designed to put guards on
    /// users of the block device (and hence the Volume API).
    ///
    /// Currently the partition limit is not persisted across reboots but this may change in the
    /// future.
    pub fn r#set_partition_limit(
        &self,
        mut guid: &Guid,
        mut slice_count: u64,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        VolumeManagerProxyInterface::r#set_partition_limit(self, guid, slice_count)
    }

    /// Renames the specified partition. Any existing devices that include the name of the partition
    /// in their topological path might *not* reflect the name change until the next time that the
    /// device is instantiated.
    pub fn r#set_partition_name(
        &self,
        mut guid: &Guid,
        mut name: &str,
    ) -> fidl::client::QueryResponseFut<
        VolumeManagerSetPartitionNameResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        VolumeManagerProxyInterface::r#set_partition_name(self, guid, name)
    }
}

impl VolumeManagerProxyInterface for VolumeManagerProxy {
    type AllocatePartitionResponseFut =
        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#allocate_partition(
        &self,
        mut slice_count: u64,
        mut type_: &Guid,
        mut instance: &Guid,
        mut name: &str,
        mut flags: u32,
    ) -> Self::AllocatePartitionResponseFut {
        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::<
                VolumeManagerAllocatePartitionResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5db528bfc287b696,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<VolumeManagerAllocatePartitionRequest, i32>(
            (slice_count, type_, instance, name, flags),
            0x5db528bfc287b696,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetInfoResponseFut = fidl::client::QueryResponseFut<
        (i32, Option<Box<VolumeManagerInfo>>),
        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<(i32, Option<Box<VolumeManagerInfo>>), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                VolumeManagerGetInfoResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2611214dcca5b064,
            >(_buf?)?;
            Ok((_response.status, _response.info))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            (i32, Option<Box<VolumeManagerInfo>>),
        >(
            (),
            0x2611214dcca5b064,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ActivateResponseFut =
        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#activate(&self, mut old_guid: &Guid, mut new_guid: &Guid) -> Self::ActivateResponseFut {
        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::<
                VolumeManagerActivateResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x182238d40c275be,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<VolumeManagerActivateRequest, i32>(
            (old_guid, new_guid),
            0x182238d40c275be,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetPartitionLimitResponseFut =
        fidl::client::QueryResponseFut<(i32, u64), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#get_partition_limit(&self, mut guid: &Guid) -> Self::GetPartitionLimitResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, u64), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                VolumeManagerGetPartitionLimitResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5bc9d21ea8bd52db,
            >(_buf?)?;
            Ok((_response.status, _response.slice_count))
        }
        self.client.send_query_and_decode::<VolumeManagerGetPartitionLimitRequest, (i32, u64)>(
            (guid,),
            0x5bc9d21ea8bd52db,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetPartitionLimitResponseFut =
        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#set_partition_limit(
        &self,
        mut guid: &Guid,
        mut slice_count: u64,
    ) -> Self::SetPartitionLimitResponseFut {
        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::<
                VolumeManagerSetPartitionLimitResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3a4903076534c093,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<VolumeManagerSetPartitionLimitRequest, i32>(
            (guid, slice_count),
            0x3a4903076534c093,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetPartitionNameResponseFut = fidl::client::QueryResponseFut<
        VolumeManagerSetPartitionNameResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_partition_name(
        &self,
        mut guid: &Guid,
        mut name: &str,
    ) -> Self::SetPartitionNameResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<VolumeManagerSetPartitionNameResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x26afb07b9d70ff1a,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            VolumeManagerSetPartitionNameRequest,
            VolumeManagerSetPartitionNameResult,
        >(
            (guid, name,),
            0x26afb07b9d70ff1a,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for VolumeManagerRequestStream {
    type Protocol = VolumeManagerMarker;
    type ControlHandle = VolumeManagerControlHandle;

    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 {
        VolumeManagerControlHandle { 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 VolumeManagerRequestStream {
    type Item = Result<VolumeManagerRequest, 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 VolumeManagerRequestStream 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 {
                    0x5db528bfc287b696 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            VolumeManagerAllocatePartitionRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VolumeManagerAllocatePartitionRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            VolumeManagerControlHandle { inner: this.inner.clone() };
                        Ok(VolumeManagerRequest::AllocatePartition {
                            slice_count: req.slice_count,
                            type_: req.type_,
                            instance: req.instance,
                            name: req.name,
                            flags: req.flags,

                            responder: VolumeManagerAllocatePartitionResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2611214dcca5b064 => {
                        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 =
                            VolumeManagerControlHandle { inner: this.inner.clone() };
                        Ok(VolumeManagerRequest::GetInfo {
                            responder: VolumeManagerGetInfoResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x182238d40c275be => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            VolumeManagerActivateRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VolumeManagerActivateRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            VolumeManagerControlHandle { inner: this.inner.clone() };
                        Ok(VolumeManagerRequest::Activate {
                            old_guid: req.old_guid,
                            new_guid: req.new_guid,

                            responder: VolumeManagerActivateResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5bc9d21ea8bd52db => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            VolumeManagerGetPartitionLimitRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VolumeManagerGetPartitionLimitRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            VolumeManagerControlHandle { inner: this.inner.clone() };
                        Ok(VolumeManagerRequest::GetPartitionLimit {
                            guid: req.guid,

                            responder: VolumeManagerGetPartitionLimitResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3a4903076534c093 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            VolumeManagerSetPartitionLimitRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VolumeManagerSetPartitionLimitRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            VolumeManagerControlHandle { inner: this.inner.clone() };
                        Ok(VolumeManagerRequest::SetPartitionLimit {
                            guid: req.guid,
                            slice_count: req.slice_count,

                            responder: VolumeManagerSetPartitionLimitResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x26afb07b9d70ff1a => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            VolumeManagerSetPartitionNameRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VolumeManagerSetPartitionNameRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            VolumeManagerControlHandle { inner: this.inner.clone() };
                        Ok(VolumeManagerRequest::SetPartitionName {
                            guid: req.guid,
                            name: req.name,

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

/// VolumeManager controls a collection of Volumes.
#[derive(Debug)]
pub enum VolumeManagerRequest {
    /// Allocates a virtual partition with the requested features.
    ///
    /// `slice_count` is the number of slices initially allocated to the partition, at
    /// offset zero. The number of slices allocated to a new partition must be at least one.
    /// `type` and `value` indicate type and instance GUIDs for the partition, respectively.
    /// `name` indicates the name of the new partition.
    AllocatePartition {
        slice_count: u64,
        type_: Guid,
        instance: Guid,
        name: String,
        flags: u32,
        responder: VolumeManagerAllocatePartitionResponder,
    },
    /// Gets the VolumeManagerInfo describing this instance of the `VolumeManager`.
    ///
    /// **NOTE**: GetInfo() is used to synchronize child partition device visibility with devfs.
    /// Implementations must only respond once all child partitions of `VolumeManager` have been
    /// added to devfs, to guarantee clients can safely enumerate them.
    ///
    /// See https://fxbug.dev/42077585 for more information.
    GetInfo { responder: VolumeManagerGetInfoResponder },
    /// Atomically marks a vpartition (by instance GUID) as inactive, while finding
    /// another partition (by instance GUID) and marking it as active.
    ///
    /// If the "old" partition does not exist, the GUID is ignored.
    /// If the "old" partition is the same as the "new" partition, the "old"
    /// GUID is ignored.
    /// If the "new" partition does not exist, `ZX_ERR_NOT_FOUND` is returned.
    ///
    /// This function does not destroy the "old" partition, it just marks it as
    /// inactive -- to reclaim that space, the "old" partition must be explicitly
    /// destroyed.  This destruction can also occur automatically when the FVM driver
    /// is rebound (i.e., on reboot).
    ///
    /// This function may be useful for A/B updates within the FVM,
    /// since it will allow activating updated partitions.
    Activate { old_guid: Guid, new_guid: Guid, responder: VolumeManagerActivateResponder },
    /// Retrieves the allocation limit for the partition. A return value of 0 indicates that there
    /// is no limit and the partition can be extended as long as there is available space on the
    /// device.
    ///
    /// The partition may be larger than this limit if a smaller limit was applied after the
    /// partition had already grown to the current size.
    ///
    /// Currently the partition limit is not persisted across reboots but this may change in the
    /// future.
    GetPartitionLimit { guid: Guid, responder: VolumeManagerGetPartitionLimitResponder },
    /// Sets the allocation limit for the partition. Partitions can not be extended beyond their
    /// allocation limit. The partition limit will never shrink partitions so if this value is
    /// less than the current partition size, it will keep the current size but prevent further
    /// growth.
    ///
    /// The allocation limits are on the VolumeManager API rather than on the partition because
    /// they represent a higher capability level. These limits are designed to put guards on
    /// users of the block device (and hence the Volume API).
    ///
    /// Currently the partition limit is not persisted across reboots but this may change in the
    /// future.
    SetPartitionLimit {
        guid: Guid,
        slice_count: u64,
        responder: VolumeManagerSetPartitionLimitResponder,
    },
    /// Renames the specified partition. Any existing devices that include the name of the partition
    /// in their topological path might *not* reflect the name change until the next time that the
    /// device is instantiated.
    SetPartitionName { guid: Guid, name: String, responder: VolumeManagerSetPartitionNameResponder },
}

impl VolumeManagerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_allocate_partition(
        self,
    ) -> Option<(u64, Guid, Guid, String, u32, VolumeManagerAllocatePartitionResponder)> {
        if let VolumeManagerRequest::AllocatePartition {
            slice_count,
            type_,
            instance,
            name,
            flags,
            responder,
        } = self
        {
            Some((slice_count, type_, instance, name, flags, responder))
        } else {
            None
        }
    }

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_activate(self) -> Option<(Guid, Guid, VolumeManagerActivateResponder)> {
        if let VolumeManagerRequest::Activate { old_guid, new_guid, responder } = self {
            Some((old_guid, new_guid, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_partition_limit(
        self,
    ) -> Option<(Guid, VolumeManagerGetPartitionLimitResponder)> {
        if let VolumeManagerRequest::GetPartitionLimit { guid, responder } = self {
            Some((guid, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_partition_limit(
        self,
    ) -> Option<(Guid, u64, VolumeManagerSetPartitionLimitResponder)> {
        if let VolumeManagerRequest::SetPartitionLimit { guid, slice_count, responder } = self {
            Some((guid, slice_count, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_partition_name(
        self,
    ) -> Option<(Guid, String, VolumeManagerSetPartitionNameResponder)> {
        if let VolumeManagerRequest::SetPartitionName { guid, name, responder } = self {
            Some((guid, name, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            VolumeManagerRequest::AllocatePartition { .. } => "allocate_partition",
            VolumeManagerRequest::GetInfo { .. } => "get_info",
            VolumeManagerRequest::Activate { .. } => "activate",
            VolumeManagerRequest::GetPartitionLimit { .. } => "get_partition_limit",
            VolumeManagerRequest::SetPartitionLimit { .. } => "set_partition_limit",
            VolumeManagerRequest::SetPartitionName { .. } => "set_partition_name",
        }
    }
}

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

impl VolumeManagerControlHandle {
    pub fn shutdown_with_epitaph(&self, status: impl Into<fidl::Epitaph>) {
        self.inner.shutdown_with_epitaph(status.into())
    }
}

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

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        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 VolumeManagerControlHandle {}

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

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

    fn control_handle(&self) -> &VolumeManagerControlHandle {
        &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 VolumeManagerAllocatePartitionResponder {
    /// 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::<VolumeManagerAllocatePartitionResponse>(
            (status,),
            self.tx_id,
            0x5db528bfc287b696,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

    fn control_handle(&self) -> &VolumeManagerControlHandle {
        &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 VolumeManagerActivateResponder {
    /// 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::<VolumeManagerActivateResponse>(
            (status,),
            self.tx_id,
            0x182238d40c275be,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

    fn control_handle(&self) -> &VolumeManagerControlHandle {
        &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 VolumeManagerSetPartitionLimitResponder {
    /// 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::<VolumeManagerSetPartitionLimitResponse>(
            (status,),
            self.tx_id,
            0x3a4903076534c093,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

mod internal {
    use super::*;

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

    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 BlockOpenSessionWithOptionsRequest {
        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 BlockOpenSessionWithOptionsRequest {
        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<
            BlockOpenSessionWithOptionsRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut BlockOpenSessionWithOptionsRequest
    {
        #[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::<BlockOpenSessionWithOptionsRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<BlockOpenSessionWithOptionsRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<SessionMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.session),
                    <fidl::encoding::Vector<BlockOffsetMapping, 4> as fidl::encoding::ValueTypeMarker>::borrow(&self.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::Vector<BlockOffsetMapping, 4>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            BlockOpenSessionWithOptionsRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<BlockOpenSessionWithOptionsRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for BlockOpenSessionWithOptionsRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                session: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<SessionMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                mappings: fidl::new_empty!(fidl::encoding::Vector<BlockOffsetMapping, 4>, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<SessionMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.session,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(fidl::encoding::Vector<BlockOffsetMapping, 4>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.mappings, decoder, offset + 8, _depth)?;
            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            MapperOpenSessionRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut MapperOpenSessionRequest
    {
        #[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::<MapperOpenSessionRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MapperOpenSessionRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<MapperSessionMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.session),
                    <fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.mapping_vmo),
                    <fidl::encoding::Optional<fidl::encoding::HandleType<fidl::Port, { fidl::ObjectType::PORT.into_raw() }, 2147483648>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.port),
                    <fidl::encoding::Optional<fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.delivery_queue),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<MapperSessionMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::Vmo,
                    { fidl::ObjectType::VMO.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T2: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fidl::Port,
                        { fidl::ObjectType::PORT.into_raw() },
                        2147483648,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T3: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fidl::Vmo,
                        { fidl::ObjectType::VMO.into_raw() },
                        2147483648,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            MapperOpenSessionRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2, T3)
    {
        #[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::<MapperOpenSessionRequest>(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)?;
            self.3.encode(encoder, offset + 12, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for MapperOpenSessionRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                session: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<MapperSessionMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                mapping_vmo: fidl::new_empty!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
                port: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fidl::Port,
                            { fidl::ObjectType::PORT.into_raw() },
                            2147483648,
                        >,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                delivery_queue: fidl::new_empty!(
                    fidl::encoding::Optional<
                        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::Endpoint<fidl::endpoints::ServerEnd<MapperSessionMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.session,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.mapping_vmo, decoder, offset + 4, _depth)?;
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fidl::Port,
                        { fidl::ObjectType::PORT.into_raw() },
                        2147483648,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.port,
                decoder,
                offset + 8,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fidl::Vmo,
                        { fidl::ObjectType::VMO.into_raw() },
                        2147483648,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.delivery_queue,
                decoder,
                offset + 12,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for MapperSessionOpenChildSessionRequest {
        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 MapperSessionOpenChildSessionRequest {
        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<
            MapperSessionOpenChildSessionRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut MapperSessionOpenChildSessionRequest
    {
        #[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::<MapperSessionOpenChildSessionRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MapperSessionOpenChildSessionRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<MapperSessionMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.session),
                    <fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.mapping_vmo),
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.parent_key),
                    <fidl::encoding::Optional<fidl::encoding::HandleType<fidl::Port, { fidl::ObjectType::PORT.into_raw() }, 2147483648>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.port),
                    <fidl::encoding::Optional<fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.delivery_queue),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<MapperSessionMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::Vmo,
                    { fidl::ObjectType::VMO.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T2: fidl::encoding::Encode<u64, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T3: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fidl::Port,
                        { fidl::ObjectType::PORT.into_raw() },
                        2147483648,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T4: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fidl::Vmo,
                        { fidl::ObjectType::VMO.into_raw() },
                        2147483648,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            MapperSessionOpenChildSessionRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2, T3, T4)
    {
        #[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::<MapperSessionOpenChildSessionRequest>(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)?;
            self.3.encode(encoder, offset + 16, depth)?;
            self.4.encode(encoder, offset + 20, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for MapperSessionOpenChildSessionRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                session: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<MapperSessionMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                mapping_vmo: fidl::new_empty!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
                parent_key: fidl::new_empty!(u64, fidl::encoding::DefaultFuchsiaResourceDialect),
                port: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fidl::Port,
                            { fidl::ObjectType::PORT.into_raw() },
                            2147483648,
                        >,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                delivery_queue: fidl::new_empty!(
                    fidl::encoding::Optional<
                        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::Endpoint<fidl::endpoints::ServerEnd<MapperSessionMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.session,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.mapping_vmo, decoder, offset + 4, _depth)?;
            fidl::decode!(
                u64,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.parent_key,
                decoder,
                offset + 8,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fidl::Port,
                        { fidl::ObjectType::PORT.into_raw() },
                        2147483648,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.port,
                decoder,
                offset + 16,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fidl::Vmo,
                        { fidl::ObjectType::VMO.into_raw() },
                        2147483648,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.delivery_queue,
                decoder,
                offset + 20,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for MapperSessionCreateVmoResponse {
        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 MapperSessionCreateVmoResponse {
        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<
            MapperSessionCreateVmoResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut MapperSessionCreateVmoResponse
    {
        #[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::<MapperSessionCreateVmoResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                MapperSessionCreateVmoResponse,
                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<
            MapperSessionCreateVmoResponse,
            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::<MapperSessionCreateVmoResponse>(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 MapperSessionCreateVmoResponse
    {
        #[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(())
        }
    }
}