fdomain_fuchsia_storage_block/

fdomain_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 fdomain_client::fidl::{ControlHandle as _, FDomainFlexibleIntoResult as _, Responder as _};
use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
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 BlockOpenSessionRequest {
    pub session: fdomain_client::fidl::ServerEnd<SessionMarker>,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect> for BlockOpenSessionRequest {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct BlockOpenSessionWithOptionsRequest {
    pub session: fdomain_client::fidl::ServerEnd<SessionMarker>,
    pub mappings: Vec<BlockOffsetMapping>,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect>
    for BlockOpenSessionWithOptionsRequest
{
}

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

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect> for SessionAttachVmoRequest {}

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

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect> for SessionGetFifoResponse {}

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

impl fdomain_client::fidl::ProtocolMarker for BlockMarker {
    type Proxy = BlockProxy;
    type RequestStream = BlockRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.storage.block.Block";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for BlockMarker {}
pub type BlockGetInfoResult = Result<BlockInfo, 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: fdomain_client::fidl::ServerEnd<SessionMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#open_session_with_options(
        &self,
        session: fdomain_client::fidl::ServerEnd<SessionMarker>,
        mappings: &[BlockOffsetMapping],
    ) -> Result<(), fidl::Error>;
    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, Clone)]
pub struct BlockProxy {
    client: fidl::client::Client<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

impl BlockProxy {
    /// Create a new Proxy for fuchsia.storage.block/Block.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name = <BlockMarker as fdomain_client::fidl::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,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        BlockProxyInterface::r#get_info(self)
    }

    /// Opens a new FIFO-based session on the block device.
    pub fn r#open_session(
        &self,
        mut session: fdomain_client::fidl::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: fdomain_client::fidl::ServerEnd<SessionMarker>,
        mut mappings: &[BlockOffsetMapping],
    ) -> Result<(), fidl::Error> {
        BlockProxyInterface::r#open_session_with_options(self, session, mappings)
    }

    /// 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>>),
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        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>>),
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        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>),
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        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,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        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),
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        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>>),
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        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, fdomain_client::fidl::FDomainResourceDialect> {
        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, fdomain_client::fidl::FDomainResourceDialect> {
        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, fdomain_client::fidl::FDomainResourceDialect> {
        BlockProxyInterface::r#destroy(self)
    }
}

impl BlockProxyInterface for BlockProxy {
    type GetInfoResponseFut = fidl::client::QueryResponseFut<
        BlockGetInfoResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_info(&self) -> Self::GetInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BlockGetInfoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<BlockGetInfoResponse, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                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: fdomain_client::fidl::ServerEnd<SessionMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<BlockOpenSessionRequest>(
            (session,),
            0x2ca32f8c64f1d6c8,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

    type GetTypeGuidResponseFut = fidl::client::QueryResponseFut<
        (i32, Option<Box<Guid>>),
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_type_guid(&self) -> Self::GetTypeGuidResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, Option<Box<Guid>>), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                BlockGetTypeGuidResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                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>>),
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_instance_guid(&self) -> Self::GetInstanceGuidResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, Option<Box<Guid>>), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                BlockGetInstanceGuidResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                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>),
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_name(&self) -> Self::GetNameResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, Option<String>), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                BlockGetNameResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                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,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_metadata(&self) -> Self::GetMetadataResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BlockGetMetadataResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<PartitionInfo, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                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),
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#query_slices(&self, mut start_slices: &[u64]) -> Self::QuerySlicesResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, [VsliceRange; 16], u64), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                BlockQuerySlicesResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                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>>),
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_volume_info(&self) -> Self::GetVolumeInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect 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,
                fdomain_client::fidl::FDomainResourceDialect,
                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, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#extend(&self, mut start_slice: u64, mut slice_count: u64) -> Self::ExtendResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                BlockExtendResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                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, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#shrink(&self, mut start_slice: u64, mut slice_count: u64) -> Self::ShrinkResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                BlockShrinkResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                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, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#destroy(&self) -> Self::DestroyResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                BlockDestroyResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                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<fdomain_client::fidl::FDomainResourceDialect>,
}

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: <fdomain_client::fidl::FDomainResourceDialect 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 fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

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

    fn from_channel(channel: fdomain_client::Channel) -> 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<fdomain_client::fidl::FDomainResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
        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::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |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(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(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,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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,
                        })
                    }
                    0xefe4e41dafce4cc => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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 fdomain_client::fidl::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: fdomain_client::fidl::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: fdomain_client::fidl::ServerEnd<SessionMarker>,
        mappings: Vec<BlockOffsetMapping>,
        control_handle: BlockControlHandle,
    },
    /// 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<(fdomain_client::fidl::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<(
        fdomain_client::fidl::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_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::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<fdomain_client::fidl::FDomainResourceDialect>>,
}

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

impl fdomain_client::fidl::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) -> fdomain_client::OnFDomainSignals {
        self.inner.channel().on_closed()
    }
}

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 fdomain_client::fidl::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 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 fdomain_client::fidl::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 fdomain_client::fidl::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 fdomain_client::fidl::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 fdomain_client::fidl::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 fdomain_client::fidl::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 fdomain_client::fidl::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 fdomain_client::fidl::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 fdomain_client::fidl::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 fdomain_client::fidl::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 SessionMarker;

impl fdomain_client::fidl::ProtocolMarker for SessionMarker {
    type Proxy = SessionProxy;
    type RequestStream = SessionRequestStream;

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

pub trait SessionProxyInterface: Send + Sync {
    type CloseResponseFut: std::future::Future<
            Output = Result<fdomain_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: fdomain_client::Vmo) -> Self::AttachVmoResponseFut;
}

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

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

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

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

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

impl SessionProxy {
    /// Create a new Proxy for fuchsia.storage.block/Session.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name = <SessionMarker as fdomain_client::fidl::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<
        fdomain_fuchsia_unknown::CloseableCloseResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        SessionProxyInterface::r#close(self)
    }

    /// Returns a handle to the client end of the FIFO.
    pub fn r#get_fifo(
        &self,
    ) -> fidl::client::QueryResponseFut<
        SessionGetFifoResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        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: fdomain_client::Vmo,
    ) -> fidl::client::QueryResponseFut<
        SessionAttachVmoResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        SessionProxyInterface::r#attach_vmo(self, vmo)
    }
}

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

    type GetFifoResponseFut = fidl::client::QueryResponseFut<
        SessionGetFifoResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_fifo(&self) -> Self::GetFifoResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SessionGetFifoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<SessionGetFifoResponse, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                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,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#attach_vmo(&self, mut vmo: fdomain_client::Vmo) -> Self::AttachVmoResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SessionAttachVmoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<SessionAttachVmoResponse, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                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<fdomain_client::fidl::FDomainResourceDialect>,
}

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: <fdomain_client::fidl::FDomainResourceDialect 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 fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

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

    fn from_channel(channel: fdomain_client::Channel) -> 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<fdomain_client::fidl::FDomainResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
        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::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |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(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(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,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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 fdomain_client::fidl::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: fdomain_client::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<(fdomain_client::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<fdomain_client::fidl::FDomainResourceDialect>>,
}

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

impl fdomain_client::fidl::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) -> fdomain_client::OnFDomainSignals {
        self.inner.channel().on_closed()
    }
}

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 fdomain_client::fidl::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 fdomain_client::fidl::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<fdomain_client::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<fdomain_client::Fifo, i32>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<fdomain_client::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 fdomain_client::fidl::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 fdomain_client::fidl::ProtocolMarker for VolumeManagerMarker {
    type Proxy = VolumeManagerProxy;
    type RequestStream = VolumeManagerRequestStream;

    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, Clone)]
pub struct VolumeManagerProxy {
    client: fidl::client::Client<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

impl VolumeManagerProxy {
    /// Create a new Proxy for fuchsia.storage.block/VolumeManager.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name =
            <VolumeManagerMarker as fdomain_client::fidl::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, fdomain_client::fidl::FDomainResourceDialect> {
        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>>),
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        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, fdomain_client::fidl::FDomainResourceDialect> {
        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), fdomain_client::fidl::FDomainResourceDialect>
    {
        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, fdomain_client::fidl::FDomainResourceDialect> {
        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,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        VolumeManagerProxyInterface::r#set_partition_name(self, guid, name)
    }
}

impl VolumeManagerProxyInterface for VolumeManagerProxy {
    type AllocatePartitionResponseFut =
        fidl::client::QueryResponseFut<i32, fdomain_client::fidl::FDomainResourceDialect>;
    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<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                VolumeManagerAllocatePartitionResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                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>>),
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_info(&self) -> Self::GetInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, Option<Box<VolumeManagerInfo>>), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                VolumeManagerGetInfoResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                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, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#activate(&self, mut old_guid: &Guid, mut new_guid: &Guid) -> Self::ActivateResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                VolumeManagerActivateResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                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), fdomain_client::fidl::FDomainResourceDialect>;
    fn r#get_partition_limit(&self, mut guid: &Guid) -> Self::GetPartitionLimitResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, u64), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                VolumeManagerGetPartitionLimitResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                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, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#set_partition_limit(
        &self,
        mut guid: &Guid,
        mut slice_count: u64,
    ) -> Self::SetPartitionLimitResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                VolumeManagerSetPartitionLimitResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                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,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#set_partition_name(
        &self,
        mut guid: &Guid,
        mut name: &str,
    ) -> Self::SetPartitionNameResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect 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>,
                fdomain_client::fidl::FDomainResourceDialect,
                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<fdomain_client::fidl::FDomainResourceDialect>,
}

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: <fdomain_client::fidl::FDomainResourceDialect 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 fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

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

    fn from_channel(channel: fdomain_client::Channel) -> 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<fdomain_client::fidl::FDomainResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
        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::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |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(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(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, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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 fdomain_client::fidl::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<fdomain_client::fidl::FDomainResourceDialect>>,
}

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

impl fdomain_client::fidl::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) -> fdomain_client::OnFDomainSignals {
        self.inner.channel().on_closed()
    }
}

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 fdomain_client::fidl::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 fdomain_client::fidl::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 fdomain_client::fidl::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 fdomain_client::fidl::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 fdomain_client::fidl::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 fdomain_client::fidl::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 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,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut BlockOpenSessionRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<BlockOpenSessionRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<BlockOpenSessionRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<SessionMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.session),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<SessionMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            BlockOpenSessionRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            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, fdomain_client::fidl::FDomainResourceDialect>
        for BlockOpenSessionRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                session: fidl::new_empty!(
                    fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<SessionMarker>>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            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<fdomain_client::fidl::ServerEnd<SessionMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
                &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,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut BlockOpenSessionWithOptionsRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<BlockOpenSessionWithOptionsRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<BlockOpenSessionWithOptionsRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fdomain_client::fidl::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<fdomain_client::fidl::ServerEnd<SessionMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::Vector<BlockOffsetMapping, 4>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            BlockOpenSessionWithOptionsRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            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, fdomain_client::fidl::FDomainResourceDialect>
        for BlockOpenSessionWithOptionsRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                session: fidl::new_empty!(
                    fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<SessionMarker>>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                mappings: fidl::new_empty!(fidl::encoding::Vector<BlockOffsetMapping, 4>, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            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<fdomain_client::fidl::ServerEnd<SessionMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.session,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(fidl::encoding::Vector<BlockOffsetMapping, 4>, fdomain_client::fidl::FDomainResourceDialect, &mut self.mappings, decoder, offset + 8, _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,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut SessionAttachVmoRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SessionAttachVmoRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                SessionAttachVmoRequest,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (<fidl::encoding::HandleType<
                    fdomain_client::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<
                    fdomain_client::Vmo,
                    { fidl::ObjectType::VMO.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            SessionAttachVmoRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            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, fdomain_client::fidl::FDomainResourceDialect>
        for SessionAttachVmoRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                vmo: fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            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<fdomain_client::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect, &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, fdomain_client::fidl::FDomainResourceDialect>
        for &mut SessionGetFifoResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SessionGetFifoResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                SessionGetFifoResponse,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (<fidl::encoding::HandleType<
                    fdomain_client::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<
                    fdomain_client::Fifo,
                    { fidl::ObjectType::FIFO.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<SessionGetFifoResponse, fdomain_client::fidl::FDomainResourceDialect>
        for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            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, fdomain_client::fidl::FDomainResourceDialect>
        for SessionGetFifoResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                fifo: fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Fifo, { fidl::ObjectType::FIFO.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            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<fdomain_client::Fifo, { fidl::ObjectType::FIFO.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect, &mut self.fifo, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }
}