fidl_fuchsia_fxfs/

fidl_fuchsia_fxfs.rs

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

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

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct BlobCreatorCreateResponse {
    pub writer: fidl::endpoints::ClientEnd<BlobWriterMarker>,
}

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

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

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

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

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

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

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct FileBackedVolumeProviderOpenRequest {
    pub parent_directory_token: fidl::Handle,
    pub name: String,
    pub server_end: fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_block_volume::VolumeMarker>,
}

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

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

impl fidl::endpoints::ProtocolMarker for BlobCreatorMarker {
    type Proxy = BlobCreatorProxy;
    type RequestStream = BlobCreatorRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = BlobCreatorSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.fxfs.BlobCreator";
}
impl fidl::endpoints::DiscoverableProtocolMarker for BlobCreatorMarker {}
pub type BlobCreatorCreateResult =
    Result<fidl::endpoints::ClientEnd<BlobWriterMarker>, CreateBlobError>;

pub trait BlobCreatorProxyInterface: Send + Sync {
    type CreateResponseFut: std::future::Future<Output = Result<BlobCreatorCreateResult, fidl::Error>>
        + Send;
    fn r#create(&self, hash: &[u8; 32], allow_existing: bool) -> Self::CreateResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct BlobCreatorSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for BlobCreatorSynchronousProxy {
    type Proxy = BlobCreatorProxy;
    type Protocol = BlobCreatorMarker;

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

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

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

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

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

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<BlobCreatorEvent, fidl::Error> {
        BlobCreatorEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Creates a blob with the merkle root `hash`. If `allow_existing` is true, the server will
    /// overwrite the existing blob if there is one. The server may fail this request with
    /// `[CreateBlobError.ALREADY_EXISTS]` if there is already an inflight `BlobWriter` for the same
    /// hash which has not been closed or completed. The client will truncate the blob with
    /// [BlobWriter.GetVmo] and get a handle to a vmo in return. The client will then write blob
    /// contents into the vmo and call [BlobWriter.BytesReady] on the 'writer` to signal to the
    /// server that some number of bytes has been written to the vmo.
    pub fn r#create(
        &self,
        mut hash: &[u8; 32],
        mut allow_existing: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BlobCreatorCreateResult, fidl::Error> {
        let _response = self.client.send_query::<
            BlobCreatorCreateRequest,
            fidl::encoding::ResultType<BlobCreatorCreateResponse, CreateBlobError>,
        >(
            (hash, allow_existing,),
            0x4288fe720cca70d7,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.writer))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for BlobCreatorProxy {
    type Protocol = BlobCreatorMarker;

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

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

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

impl BlobCreatorProxy {
    /// Create a new Proxy for fuchsia.fxfs/BlobCreator.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <BlobCreatorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> BlobCreatorEventStream {
        BlobCreatorEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Creates a blob with the merkle root `hash`. If `allow_existing` is true, the server will
    /// overwrite the existing blob if there is one. The server may fail this request with
    /// `[CreateBlobError.ALREADY_EXISTS]` if there is already an inflight `BlobWriter` for the same
    /// hash which has not been closed or completed. The client will truncate the blob with
    /// [BlobWriter.GetVmo] and get a handle to a vmo in return. The client will then write blob
    /// contents into the vmo and call [BlobWriter.BytesReady] on the 'writer` to signal to the
    /// server that some number of bytes has been written to the vmo.
    pub fn r#create(
        &self,
        mut hash: &[u8; 32],
        mut allow_existing: bool,
    ) -> fidl::client::QueryResponseFut<
        BlobCreatorCreateResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BlobCreatorProxyInterface::r#create(self, hash, allow_existing)
    }
}

impl BlobCreatorProxyInterface for BlobCreatorProxy {
    type CreateResponseFut = fidl::client::QueryResponseFut<
        BlobCreatorCreateResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#create(&self, mut hash: &[u8; 32], mut allow_existing: bool) -> Self::CreateResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BlobCreatorCreateResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<BlobCreatorCreateResponse, CreateBlobError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4288fe720cca70d7,
            >(_buf?)?;
            Ok(_response.map(|x| x.writer))
        }
        self.client.send_query_and_decode::<BlobCreatorCreateRequest, BlobCreatorCreateResult>(
            (hash, allow_existing),
            0x4288fe720cca70d7,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for BlobCreatorRequestStream {
    type Protocol = BlobCreatorMarker;
    type ControlHandle = BlobCreatorControlHandle;

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

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

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

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

impl futures::Stream for BlobCreatorRequestStream {
    type Item = Result<BlobCreatorRequest, 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 BlobCreatorRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x4288fe720cca70d7 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BlobCreatorCreateRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BlobCreatorCreateRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BlobCreatorControlHandle { inner: this.inner.clone() };
                        Ok(BlobCreatorRequest::Create {
                            hash: req.hash,
                            allow_existing: req.allow_existing,

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

#[derive(Debug)]
pub enum BlobCreatorRequest {
    /// Creates a blob with the merkle root `hash`. If `allow_existing` is true, the server will
    /// overwrite the existing blob if there is one. The server may fail this request with
    /// `[CreateBlobError.ALREADY_EXISTS]` if there is already an inflight `BlobWriter` for the same
    /// hash which has not been closed or completed. The client will truncate the blob with
    /// [BlobWriter.GetVmo] and get a handle to a vmo in return. The client will then write blob
    /// contents into the vmo and call [BlobWriter.BytesReady] on the 'writer` to signal to the
    /// server that some number of bytes has been written to the vmo.
    Create { hash: [u8; 32], allow_existing: bool, responder: BlobCreatorCreateResponder },
}

impl BlobCreatorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_create(self) -> Option<([u8; 32], bool, BlobCreatorCreateResponder)> {
        if let BlobCreatorRequest::Create { hash, allow_existing, responder } = self {
            Some((hash, allow_existing, responder))
        } else {
            None
        }
    }

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

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

impl fidl::endpoints::ControlHandle for BlobCreatorControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl BlobCreatorControlHandle {}

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

/// Set the the channel to be shutdown (see [`BlobCreatorControlHandle::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 BlobCreatorCreateResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BlobCreatorCreateResponder {
    type ControlHandle = BlobCreatorControlHandle;

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

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

    fn send_raw(
        &self,
        mut result: Result<fidl::endpoints::ClientEnd<BlobWriterMarker>, CreateBlobError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BlobCreatorCreateResponse,
            CreateBlobError,
        >>(
            result.map(|writer| (writer,)),
            self.tx_id,
            0x4288fe720cca70d7,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for BlobReaderMarker {
    type Proxy = BlobReaderProxy;
    type RequestStream = BlobReaderRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = BlobReaderSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.fxfs.BlobReader";
}
impl fidl::endpoints::DiscoverableProtocolMarker for BlobReaderMarker {}
pub type BlobReaderGetVmoResult = Result<fidl::Vmo, i32>;

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

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for BlobReaderSynchronousProxy {
    type Proxy = BlobReaderProxy;
    type Protocol = BlobReaderMarker;

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

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

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

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

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

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<BlobReaderEvent, fidl::Error> {
        BlobReaderEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Given the hash of a blob, returns a VMO with its contents.
    pub fn r#get_vmo(
        &self,
        mut blob_hash: &[u8; 32],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BlobReaderGetVmoResult, fidl::Error> {
        let _response = self.client.send_query::<
            BlobReaderGetVmoRequest,
            fidl::encoding::ResultType<BlobReaderGetVmoResponse, i32>,
        >(
            (blob_hash,),
            0x2fa72823ef7f11f4,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.vmo))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for BlobReaderProxy {
    type Protocol = BlobReaderMarker;

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

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

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

impl BlobReaderProxy {
    /// Create a new Proxy for fuchsia.fxfs/BlobReader.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <BlobReaderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> BlobReaderEventStream {
        BlobReaderEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Given the hash of a blob, returns a VMO with its contents.
    pub fn r#get_vmo(
        &self,
        mut blob_hash: &[u8; 32],
    ) -> fidl::client::QueryResponseFut<
        BlobReaderGetVmoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BlobReaderProxyInterface::r#get_vmo(self, blob_hash)
    }
}

impl BlobReaderProxyInterface for BlobReaderProxy {
    type GetVmoResponseFut = fidl::client::QueryResponseFut<
        BlobReaderGetVmoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_vmo(&self, mut blob_hash: &[u8; 32]) -> Self::GetVmoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BlobReaderGetVmoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<BlobReaderGetVmoResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2fa72823ef7f11f4,
            >(_buf?)?;
            Ok(_response.map(|x| x.vmo))
        }
        self.client.send_query_and_decode::<BlobReaderGetVmoRequest, BlobReaderGetVmoResult>(
            (blob_hash,),
            0x2fa72823ef7f11f4,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for BlobReaderRequestStream {
    type Protocol = BlobReaderMarker;
    type ControlHandle = BlobReaderControlHandle;

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

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

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

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

impl futures::Stream for BlobReaderRequestStream {
    type Item = Result<BlobReaderRequest, 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 BlobReaderRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x2fa72823ef7f11f4 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BlobReaderGetVmoRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BlobReaderGetVmoRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BlobReaderControlHandle { inner: this.inner.clone() };
                        Ok(BlobReaderRequest::GetVmo {
                            blob_hash: req.blob_hash,

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

#[derive(Debug)]
pub enum BlobReaderRequest {
    /// Given the hash of a blob, returns a VMO with its contents.
    GetVmo { blob_hash: [u8; 32], responder: BlobReaderGetVmoResponder },
}

impl BlobReaderRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_vmo(self) -> Option<([u8; 32], BlobReaderGetVmoResponder)> {
        if let BlobReaderRequest::GetVmo { blob_hash, responder } = self {
            Some((blob_hash, responder))
        } else {
            None
        }
    }

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

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

impl fidl::endpoints::ControlHandle for BlobReaderControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl BlobReaderControlHandle {}

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

/// Set the the channel to be shutdown (see [`BlobReaderControlHandle::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 BlobReaderGetVmoResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BlobReaderGetVmoResponder {
    type ControlHandle = BlobReaderControlHandle;

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

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

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

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

impl fidl::endpoints::ProtocolMarker for BlobVolumeWriterMarker {
    type Proxy = BlobVolumeWriterProxy;
    type RequestStream = BlobVolumeWriterRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = BlobVolumeWriterSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.fxfs.BlobVolumeWriter";
}
impl fidl::endpoints::DiscoverableProtocolMarker for BlobVolumeWriterMarker {}
pub type BlobVolumeWriterWriteResult = Result<(), i32>;

pub trait BlobVolumeWriterProxyInterface: Send + Sync {
    type WriteResponseFut: std::future::Future<Output = Result<BlobVolumeWriterWriteResult, fidl::Error>>
        + Send;
    fn r#write(&self, payload: fidl::Vmo) -> Self::WriteResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct BlobVolumeWriterSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for BlobVolumeWriterSynchronousProxy {
    type Proxy = BlobVolumeWriterProxy;
    type Protocol = BlobVolumeWriterMarker;

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

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

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

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

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

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<BlobVolumeWriterEvent, fidl::Error> {
        BlobVolumeWriterEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Writes the blob volume from `payload` into this partition. `payload` must be an fxfs
    /// partition containing a single volume named "blob" in the Android sparse format.
    ///
    /// *WARNING*: The system may not boot if this process is interrupted.
    pub fn r#write(
        &self,
        mut payload: fidl::Vmo,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BlobVolumeWriterWriteResult, fidl::Error> {
        let _response = self.client.send_query::<
            BlobVolumeWriterWriteRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (payload,),
            0x2c22511f39661c37,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for BlobVolumeWriterProxy {
    type Protocol = BlobVolumeWriterMarker;

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

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

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

impl BlobVolumeWriterProxy {
    /// Create a new Proxy for fuchsia.fxfs/BlobVolumeWriter.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <BlobVolumeWriterMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> BlobVolumeWriterEventStream {
        BlobVolumeWriterEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Writes the blob volume from `payload` into this partition. `payload` must be an fxfs
    /// partition containing a single volume named "blob" in the Android sparse format.
    ///
    /// *WARNING*: The system may not boot if this process is interrupted.
    pub fn r#write(
        &self,
        mut payload: fidl::Vmo,
    ) -> fidl::client::QueryResponseFut<
        BlobVolumeWriterWriteResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BlobVolumeWriterProxyInterface::r#write(self, payload)
    }
}

impl BlobVolumeWriterProxyInterface for BlobVolumeWriterProxy {
    type WriteResponseFut = fidl::client::QueryResponseFut<
        BlobVolumeWriterWriteResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#write(&self, mut payload: fidl::Vmo) -> Self::WriteResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BlobVolumeWriterWriteResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2c22511f39661c37,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BlobVolumeWriterWriteRequest, BlobVolumeWriterWriteResult>(
                (payload,),
                0x2c22511f39661c37,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for BlobVolumeWriterRequestStream {
    type Protocol = BlobVolumeWriterMarker;
    type ControlHandle = BlobVolumeWriterControlHandle;

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

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

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

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

impl futures::Stream for BlobVolumeWriterRequestStream {
    type Item = Result<BlobVolumeWriterRequest, 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 BlobVolumeWriterRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x2c22511f39661c37 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BlobVolumeWriterWriteRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BlobVolumeWriterWriteRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BlobVolumeWriterControlHandle { inner: this.inner.clone() };
                        Ok(BlobVolumeWriterRequest::Write {
                            payload: req.payload,

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

/// Internal protocol used for streaming a new blob volume to disk.
///
/// This is intended primarily for use with paving/fastboot workflows which need to overwrite the
/// system blob volume, while preserving other existing volumes (e.g. userdata).
///
/// *WARNING*: Still under development, may result in unrecoverable data loss. Use at your own risk!
#[derive(Debug)]
pub enum BlobVolumeWriterRequest {
    /// Writes the blob volume from `payload` into this partition. `payload` must be an fxfs
    /// partition containing a single volume named "blob" in the Android sparse format.
    ///
    /// *WARNING*: The system may not boot if this process is interrupted.
    Write { payload: fidl::Vmo, responder: BlobVolumeWriterWriteResponder },
}

impl BlobVolumeWriterRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_write(self) -> Option<(fidl::Vmo, BlobVolumeWriterWriteResponder)> {
        if let BlobVolumeWriterRequest::Write { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

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

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

impl fidl::endpoints::ControlHandle for BlobVolumeWriterControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl BlobVolumeWriterControlHandle {}

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

/// Set the the channel to be shutdown (see [`BlobVolumeWriterControlHandle::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 BlobVolumeWriterWriteResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BlobVolumeWriterWriteResponder {
    type ControlHandle = BlobVolumeWriterControlHandle;

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

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

impl fidl::endpoints::ProtocolMarker for BlobWriterMarker {
    type Proxy = BlobWriterProxy;
    type RequestStream = BlobWriterRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = BlobWriterSynchronousProxy;

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

pub trait BlobWriterProxyInterface: Send + Sync {
    type GetVmoResponseFut: std::future::Future<Output = Result<BlobWriterGetVmoResult, fidl::Error>>
        + Send;
    fn r#get_vmo(&self, size: u64) -> Self::GetVmoResponseFut;
    type BytesReadyResponseFut: std::future::Future<Output = Result<BlobWriterBytesReadyResult, fidl::Error>>
        + Send;
    fn r#bytes_ready(&self, bytes_written: u64) -> Self::BytesReadyResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct BlobWriterSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for BlobWriterSynchronousProxy {
    type Proxy = BlobWriterProxy;
    type Protocol = BlobWriterMarker;

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

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

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

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

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

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<BlobWriterEvent, fidl::Error> {
        BlobWriterEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Truncates the blob associated with this BlobWriter proxy to length `size`. Returns a handle
    /// to a `vmo` shared between the server and the client, which is implemented as a ring buffer.
    /// As the client writes blob contents into the `vmo`, it will call BytesReady to signal to the
    /// server that some number of bytes have been written.
    ///
    /// Ring Buffer Semantics
    /// The server sets the size of the vmo passed back to the client. The chunks that the client
    /// writes are arbitrarily sized and do not have any alignment guarantees. Any particular write
    /// can wrap around the ring buffer. The client can have several outstanding BytesReady
    /// requests but the client is responsible for not overwriting a given range in the ring buffer
    /// until the BytesReady request corresponding to that range has completed.
    pub fn r#get_vmo(
        &self,
        mut size: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BlobWriterGetVmoResult, fidl::Error> {
        let _response = self.client.send_query::<
            BlobWriterGetVmoRequest,
            fidl::encoding::ResultType<BlobWriterGetVmoResponse, i32>,
        >(
            (size,),
            0x50c8988b12b6f893,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.vmo))
    }

    /// Indicates to the server that an additional `bytes_written` number of bytes have been
    /// written to the shared vmo and are ready to be read off the vmo and written to disk. The
    /// blob will be readable when the final BytesReady response is received by the client.
    pub fn r#bytes_ready(
        &self,
        mut bytes_written: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BlobWriterBytesReadyResult, fidl::Error> {
        let _response = self.client.send_query::<
            BlobWriterBytesReadyRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (bytes_written,),
            0x7b308b473606c573,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for BlobWriterProxy {
    type Protocol = BlobWriterMarker;

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

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

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

impl BlobWriterProxy {
    /// Create a new Proxy for fuchsia.fxfs/BlobWriter.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <BlobWriterMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> BlobWriterEventStream {
        BlobWriterEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Truncates the blob associated with this BlobWriter proxy to length `size`. Returns a handle
    /// to a `vmo` shared between the server and the client, which is implemented as a ring buffer.
    /// As the client writes blob contents into the `vmo`, it will call BytesReady to signal to the
    /// server that some number of bytes have been written.
    ///
    /// Ring Buffer Semantics
    /// The server sets the size of the vmo passed back to the client. The chunks that the client
    /// writes are arbitrarily sized and do not have any alignment guarantees. Any particular write
    /// can wrap around the ring buffer. The client can have several outstanding BytesReady
    /// requests but the client is responsible for not overwriting a given range in the ring buffer
    /// until the BytesReady request corresponding to that range has completed.
    pub fn r#get_vmo(
        &self,
        mut size: u64,
    ) -> fidl::client::QueryResponseFut<
        BlobWriterGetVmoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BlobWriterProxyInterface::r#get_vmo(self, size)
    }

    /// Indicates to the server that an additional `bytes_written` number of bytes have been
    /// written to the shared vmo and are ready to be read off the vmo and written to disk. The
    /// blob will be readable when the final BytesReady response is received by the client.
    pub fn r#bytes_ready(
        &self,
        mut bytes_written: u64,
    ) -> fidl::client::QueryResponseFut<
        BlobWriterBytesReadyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BlobWriterProxyInterface::r#bytes_ready(self, bytes_written)
    }
}

impl BlobWriterProxyInterface for BlobWriterProxy {
    type GetVmoResponseFut = fidl::client::QueryResponseFut<
        BlobWriterGetVmoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_vmo(&self, mut size: u64) -> Self::GetVmoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BlobWriterGetVmoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<BlobWriterGetVmoResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x50c8988b12b6f893,
            >(_buf?)?;
            Ok(_response.map(|x| x.vmo))
        }
        self.client.send_query_and_decode::<BlobWriterGetVmoRequest, BlobWriterGetVmoResult>(
            (size,),
            0x50c8988b12b6f893,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type BytesReadyResponseFut = fidl::client::QueryResponseFut<
        BlobWriterBytesReadyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#bytes_ready(&self, mut bytes_written: u64) -> Self::BytesReadyResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BlobWriterBytesReadyResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7b308b473606c573,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BlobWriterBytesReadyRequest, BlobWriterBytesReadyResult>(
                (bytes_written,),
                0x7b308b473606c573,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for BlobWriterRequestStream {
    type Protocol = BlobWriterMarker;
    type ControlHandle = BlobWriterControlHandle;

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

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

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

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

impl futures::Stream for BlobWriterRequestStream {
    type Item = Result<BlobWriterRequest, 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 BlobWriterRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x50c8988b12b6f893 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BlobWriterGetVmoRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BlobWriterGetVmoRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BlobWriterControlHandle { inner: this.inner.clone() };
                        Ok(BlobWriterRequest::GetVmo {
                            size: req.size,

                            responder: BlobWriterGetVmoResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7b308b473606c573 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BlobWriterBytesReadyRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BlobWriterBytesReadyRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BlobWriterControlHandle { inner: this.inner.clone() };
                        Ok(BlobWriterRequest::BytesReady {
                            bytes_written: req.bytes_written,

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

#[derive(Debug)]
pub enum BlobWriterRequest {
    /// Truncates the blob associated with this BlobWriter proxy to length `size`. Returns a handle
    /// to a `vmo` shared between the server and the client, which is implemented as a ring buffer.
    /// As the client writes blob contents into the `vmo`, it will call BytesReady to signal to the
    /// server that some number of bytes have been written.
    ///
    /// Ring Buffer Semantics
    /// The server sets the size of the vmo passed back to the client. The chunks that the client
    /// writes are arbitrarily sized and do not have any alignment guarantees. Any particular write
    /// can wrap around the ring buffer. The client can have several outstanding BytesReady
    /// requests but the client is responsible for not overwriting a given range in the ring buffer
    /// until the BytesReady request corresponding to that range has completed.
    GetVmo { size: u64, responder: BlobWriterGetVmoResponder },
    /// Indicates to the server that an additional `bytes_written` number of bytes have been
    /// written to the shared vmo and are ready to be read off the vmo and written to disk. The
    /// blob will be readable when the final BytesReady response is received by the client.
    BytesReady { bytes_written: u64, responder: BlobWriterBytesReadyResponder },
}

impl BlobWriterRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_vmo(self) -> Option<(u64, BlobWriterGetVmoResponder)> {
        if let BlobWriterRequest::GetVmo { size, responder } = self {
            Some((size, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_bytes_ready(self) -> Option<(u64, BlobWriterBytesReadyResponder)> {
        if let BlobWriterRequest::BytesReady { bytes_written, responder } = self {
            Some((bytes_written, responder))
        } else {
            None
        }
    }

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

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

impl fidl::endpoints::ControlHandle for BlobWriterControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl BlobWriterControlHandle {}

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

/// Set the the channel to be shutdown (see [`BlobWriterControlHandle::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 BlobWriterGetVmoResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BlobWriterGetVmoResponder {
    type ControlHandle = BlobWriterControlHandle;

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

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

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

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

/// Set the the channel to be shutdown (see [`BlobWriterControlHandle::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 BlobWriterBytesReadyResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BlobWriterBytesReadyResponder {
    type ControlHandle = BlobWriterControlHandle;

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

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

impl fidl::endpoints::ProtocolMarker for CryptMarker {
    type Proxy = CryptProxy;
    type RequestStream = CryptRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = CryptSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.fxfs.Crypt";
}
impl fidl::endpoints::DiscoverableProtocolMarker for CryptMarker {}
pub type CryptCreateKeyResult = Result<([u8; 16], Vec<u8>, Vec<u8>), i32>;
pub type CryptCreateKeyWithIdResult = Result<(Vec<u8>, Vec<u8>), i32>;
pub type CryptUnwrapKeyResult = Result<Vec<u8>, i32>;

pub trait CryptProxyInterface: Send + Sync {
    type CreateKeyResponseFut: std::future::Future<Output = Result<CryptCreateKeyResult, fidl::Error>>
        + Send;
    fn r#create_key(&self, owner: u64, purpose: KeyPurpose) -> Self::CreateKeyResponseFut;
    type CreateKeyWithIdResponseFut: std::future::Future<Output = Result<CryptCreateKeyWithIdResult, fidl::Error>>
        + Send;
    fn r#create_key_with_id(
        &self,
        owner: u64,
        wrapping_key_id: &[u8; 16],
    ) -> Self::CreateKeyWithIdResponseFut;
    type UnwrapKeyResponseFut: std::future::Future<Output = Result<CryptUnwrapKeyResult, fidl::Error>>
        + Send;
    fn r#unwrap_key(&self, owner: u64, wrapped_key: &WrappedKey) -> Self::UnwrapKeyResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct CryptSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for CryptSynchronousProxy {
    type Proxy = CryptProxy;
    type Protocol = CryptMarker;

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

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

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

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

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

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<CryptEvent, fidl::Error> {
        CryptEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Creates a new key wrapped with the key identified by `wrapping_key_id`.  `owner` identifies
    /// the owner of the key and must be supplied to `UnwrapKey`.  The crypt service chooses a
    /// `wrapping_key_id` which must be supplied to UnwrapKey.  The `wrapping_key_id` has no
    /// meaning to Fxfs.
    pub fn r#create_key(
        &self,
        mut owner: u64,
        mut purpose: KeyPurpose,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<CryptCreateKeyResult, fidl::Error> {
        let _response = self.client.send_query::<
            CryptCreateKeyRequest,
            fidl::encoding::ResultType<CryptCreateKeyResponse, i32>,
        >(
            (owner, purpose,),
            0x6ec69b3aee7fdbba,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| (x.wrapping_key_id, x.wrapped_key, x.unwrapped_key)))
    }

    /// Creates a new key wrapped with the key identified by `wrapping_key_id`.  `owner` identifies
    /// the owner of the key and must be supplied to `UnwrapKey` along with  `wrapping_key_id`.
    /// The `wrapping_key_id` has no meaning to Fxfs.
    pub fn r#create_key_with_id(
        &self,
        mut owner: u64,
        mut wrapping_key_id: &[u8; 16],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<CryptCreateKeyWithIdResult, fidl::Error> {
        let _response = self.client.send_query::<
            CryptCreateKeyWithIdRequest,
            fidl::encoding::ResultType<CryptCreateKeyWithIdResponse, i32>,
        >(
            (owner, wrapping_key_id,),
            0x21e8076688700b50,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| (x.wrapped_key, x.unwrapped_key)))
    }

    /// Unwraps a key.  `owner` must be the same as that passed to `CreateKey`.
    /// This can fail due to permission reasons, but an incorrect key or owner will not fail;
    /// it will just return an unwrapped key that won't actually decrpyt the data.
    pub fn r#unwrap_key(
        &self,
        mut owner: u64,
        mut wrapped_key: &WrappedKey,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<CryptUnwrapKeyResult, fidl::Error> {
        let _response = self.client.send_query::<
            CryptUnwrapKeyRequest,
            fidl::encoding::ResultType<CryptUnwrapKeyResponse, i32>,
        >(
            (owner, wrapped_key,),
            0x6ec34e2b64d46be9,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.unwrapped_key))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for CryptProxy {
    type Protocol = CryptMarker;

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

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

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

impl CryptProxy {
    /// Create a new Proxy for fuchsia.fxfs/Crypt.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <CryptMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> CryptEventStream {
        CryptEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Creates a new key wrapped with the key identified by `wrapping_key_id`.  `owner` identifies
    /// the owner of the key and must be supplied to `UnwrapKey`.  The crypt service chooses a
    /// `wrapping_key_id` which must be supplied to UnwrapKey.  The `wrapping_key_id` has no
    /// meaning to Fxfs.
    pub fn r#create_key(
        &self,
        mut owner: u64,
        mut purpose: KeyPurpose,
    ) -> fidl::client::QueryResponseFut<
        CryptCreateKeyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        CryptProxyInterface::r#create_key(self, owner, purpose)
    }

    /// Creates a new key wrapped with the key identified by `wrapping_key_id`.  `owner` identifies
    /// the owner of the key and must be supplied to `UnwrapKey` along with  `wrapping_key_id`.
    /// The `wrapping_key_id` has no meaning to Fxfs.
    pub fn r#create_key_with_id(
        &self,
        mut owner: u64,
        mut wrapping_key_id: &[u8; 16],
    ) -> fidl::client::QueryResponseFut<
        CryptCreateKeyWithIdResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        CryptProxyInterface::r#create_key_with_id(self, owner, wrapping_key_id)
    }

    /// Unwraps a key.  `owner` must be the same as that passed to `CreateKey`.
    /// This can fail due to permission reasons, but an incorrect key or owner will not fail;
    /// it will just return an unwrapped key that won't actually decrpyt the data.
    pub fn r#unwrap_key(
        &self,
        mut owner: u64,
        mut wrapped_key: &WrappedKey,
    ) -> fidl::client::QueryResponseFut<
        CryptUnwrapKeyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        CryptProxyInterface::r#unwrap_key(self, owner, wrapped_key)
    }
}

impl CryptProxyInterface for CryptProxy {
    type CreateKeyResponseFut = fidl::client::QueryResponseFut<
        CryptCreateKeyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#create_key(&self, mut owner: u64, mut purpose: KeyPurpose) -> Self::CreateKeyResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<CryptCreateKeyResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<CryptCreateKeyResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6ec69b3aee7fdbba,
            >(_buf?)?;
            Ok(_response.map(|x| (x.wrapping_key_id, x.wrapped_key, x.unwrapped_key)))
        }
        self.client.send_query_and_decode::<CryptCreateKeyRequest, CryptCreateKeyResult>(
            (owner, purpose),
            0x6ec69b3aee7fdbba,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type CreateKeyWithIdResponseFut = fidl::client::QueryResponseFut<
        CryptCreateKeyWithIdResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#create_key_with_id(
        &self,
        mut owner: u64,
        mut wrapping_key_id: &[u8; 16],
    ) -> Self::CreateKeyWithIdResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<CryptCreateKeyWithIdResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<CryptCreateKeyWithIdResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x21e8076688700b50,
            >(_buf?)?;
            Ok(_response.map(|x| (x.wrapped_key, x.unwrapped_key)))
        }
        self.client
            .send_query_and_decode::<CryptCreateKeyWithIdRequest, CryptCreateKeyWithIdResult>(
                (owner, wrapping_key_id),
                0x21e8076688700b50,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type UnwrapKeyResponseFut = fidl::client::QueryResponseFut<
        CryptUnwrapKeyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#unwrap_key(
        &self,
        mut owner: u64,
        mut wrapped_key: &WrappedKey,
    ) -> Self::UnwrapKeyResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<CryptUnwrapKeyResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<CryptUnwrapKeyResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6ec34e2b64d46be9,
            >(_buf?)?;
            Ok(_response.map(|x| x.unwrapped_key))
        }
        self.client.send_query_and_decode::<CryptUnwrapKeyRequest, CryptUnwrapKeyResult>(
            (owner, wrapped_key),
            0x6ec34e2b64d46be9,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for CryptRequestStream {
    type Protocol = CryptMarker;
    type ControlHandle = CryptControlHandle;

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

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

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

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

impl futures::Stream for CryptRequestStream {
    type Item = Result<CryptRequest, 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 CryptRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x6ec69b3aee7fdbba => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            CryptCreateKeyRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<CryptCreateKeyRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = CryptControlHandle { inner: this.inner.clone() };
                        Ok(CryptRequest::CreateKey {
                            owner: req.owner,
                            purpose: req.purpose,

                            responder: CryptCreateKeyResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x21e8076688700b50 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            CryptCreateKeyWithIdRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<CryptCreateKeyWithIdRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = CryptControlHandle { inner: this.inner.clone() };
                        Ok(CryptRequest::CreateKeyWithId {
                            owner: req.owner,
                            wrapping_key_id: req.wrapping_key_id,

                            responder: CryptCreateKeyWithIdResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6ec34e2b64d46be9 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            CryptUnwrapKeyRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<CryptUnwrapKeyRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = CryptControlHandle { inner: this.inner.clone() };
                        Ok(CryptRequest::UnwrapKey {
                            owner: req.owner,
                            wrapped_key: req.wrapped_key,

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

#[derive(Debug)]
pub enum CryptRequest {
    /// Creates a new key wrapped with the key identified by `wrapping_key_id`.  `owner` identifies
    /// the owner of the key and must be supplied to `UnwrapKey`.  The crypt service chooses a
    /// `wrapping_key_id` which must be supplied to UnwrapKey.  The `wrapping_key_id` has no
    /// meaning to Fxfs.
    CreateKey { owner: u64, purpose: KeyPurpose, responder: CryptCreateKeyResponder },
    /// Creates a new key wrapped with the key identified by `wrapping_key_id`.  `owner` identifies
    /// the owner of the key and must be supplied to `UnwrapKey` along with  `wrapping_key_id`.
    /// The `wrapping_key_id` has no meaning to Fxfs.
    CreateKeyWithId {
        owner: u64,
        wrapping_key_id: [u8; 16],
        responder: CryptCreateKeyWithIdResponder,
    },
    /// Unwraps a key.  `owner` must be the same as that passed to `CreateKey`.
    /// This can fail due to permission reasons, but an incorrect key or owner will not fail;
    /// it will just return an unwrapped key that won't actually decrpyt the data.
    UnwrapKey { owner: u64, wrapped_key: WrappedKey, responder: CryptUnwrapKeyResponder },
}

impl CryptRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_create_key(self) -> Option<(u64, KeyPurpose, CryptCreateKeyResponder)> {
        if let CryptRequest::CreateKey { owner, purpose, responder } = self {
            Some((owner, purpose, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_create_key_with_id(self) -> Option<(u64, [u8; 16], CryptCreateKeyWithIdResponder)> {
        if let CryptRequest::CreateKeyWithId { owner, wrapping_key_id, responder } = self {
            Some((owner, wrapping_key_id, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_unwrap_key(self) -> Option<(u64, WrappedKey, CryptUnwrapKeyResponder)> {
        if let CryptRequest::UnwrapKey { owner, wrapped_key, responder } = self {
            Some((owner, wrapped_key, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            CryptRequest::CreateKey { .. } => "create_key",
            CryptRequest::CreateKeyWithId { .. } => "create_key_with_id",
            CryptRequest::UnwrapKey { .. } => "unwrap_key",
        }
    }
}

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

impl fidl::endpoints::ControlHandle for CryptControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl CryptControlHandle {}

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

/// Set the the channel to be shutdown (see [`CryptControlHandle::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 CryptCreateKeyResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for CryptCreateKeyResponder {
    type ControlHandle = CryptControlHandle;

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

    fn send_raw(
        &self,
        mut result: Result<(&[u8; 16], &[u8], &[u8]), i32>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<CryptCreateKeyResponse, i32>>(
            result,
            self.tx_id,
            0x6ec69b3aee7fdbba,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`CryptControlHandle::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 CryptCreateKeyWithIdResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for CryptCreateKeyWithIdResponder {
    type ControlHandle = CryptControlHandle;

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

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

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

/// Set the the channel to be shutdown (see [`CryptControlHandle::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 CryptUnwrapKeyResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for CryptUnwrapKeyResponder {
    type ControlHandle = CryptControlHandle;

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

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

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

impl fidl::endpoints::ProtocolMarker for CryptManagementMarker {
    type Proxy = CryptManagementProxy;
    type RequestStream = CryptManagementRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = CryptManagementSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.fxfs.CryptManagement";
}
impl fidl::endpoints::DiscoverableProtocolMarker for CryptManagementMarker {}
pub type CryptManagementAddWrappingKeyResult = Result<(), i32>;
pub type CryptManagementSetActiveKeyResult = Result<(), i32>;
pub type CryptManagementForgetWrappingKeyResult = Result<(), i32>;

pub trait CryptManagementProxyInterface: Send + Sync {
    type AddWrappingKeyResponseFut: std::future::Future<Output = Result<CryptManagementAddWrappingKeyResult, fidl::Error>>
        + Send;
    fn r#add_wrapping_key(
        &self,
        wrapping_key_id: &[u8; 16],
        key: &[u8],
    ) -> Self::AddWrappingKeyResponseFut;
    type SetActiveKeyResponseFut: std::future::Future<Output = Result<CryptManagementSetActiveKeyResult, fidl::Error>>
        + Send;
    fn r#set_active_key(
        &self,
        purpose: KeyPurpose,
        wrapping_key_id: &[u8; 16],
    ) -> Self::SetActiveKeyResponseFut;
    type ForgetWrappingKeyResponseFut: std::future::Future<Output = Result<CryptManagementForgetWrappingKeyResult, fidl::Error>>
        + Send;
    fn r#forget_wrapping_key(
        &self,
        wrapping_key_id: &[u8; 16],
    ) -> Self::ForgetWrappingKeyResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct CryptManagementSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for CryptManagementSynchronousProxy {
    type Proxy = CryptManagementProxy;
    type Protocol = CryptManagementMarker;

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

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

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

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

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

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<CryptManagementEvent, fidl::Error> {
        CryptManagementEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Adds a new wrapping key to the Crypt service.  The new key will immediately be available
    /// for unwrapping keys (Crypt::UnwrapKeys) but won't be used for wrapping keys until
    /// CryptManagement::SetActiveKeys is called.
    pub fn r#add_wrapping_key(
        &self,
        mut wrapping_key_id: &[u8; 16],
        mut key: &[u8],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<CryptManagementAddWrappingKeyResult, fidl::Error> {
        let _response = self.client.send_query::<
            CryptManagementAddWrappingKeyRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (wrapping_key_id, key,),
            0x59a5076762318bf,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Updates the key which will be used for wrapping keys (Crypt::CreateKey).  `purpose`
    /// describes which active key to modify.
    pub fn r#set_active_key(
        &self,
        mut purpose: KeyPurpose,
        mut wrapping_key_id: &[u8; 16],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<CryptManagementSetActiveKeyResult, fidl::Error> {
        let _response = self.client.send_query::<
            CryptManagementSetActiveKeyRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (purpose, wrapping_key_id,),
            0x5e81d600442f2872,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Forgets a wrapping key, preventing its use for future key-unwrapping.  All future calls to
    /// Crypt::UnwrapKeys with that wrapping key ID will fail.
    /// If either the data or metadata part of the key is active, an error is returned.
    pub fn r#forget_wrapping_key(
        &self,
        mut wrapping_key_id: &[u8; 16],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<CryptManagementForgetWrappingKeyResult, fidl::Error> {
        let _response = self.client.send_query::<
            CryptManagementForgetWrappingKeyRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (wrapping_key_id,),
            0x436d6d27696dfcf4,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for CryptManagementProxy {
    type Protocol = CryptManagementMarker;

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

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

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

impl CryptManagementProxy {
    /// Create a new Proxy for fuchsia.fxfs/CryptManagement.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <CryptManagementMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> CryptManagementEventStream {
        CryptManagementEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Adds a new wrapping key to the Crypt service.  The new key will immediately be available
    /// for unwrapping keys (Crypt::UnwrapKeys) but won't be used for wrapping keys until
    /// CryptManagement::SetActiveKeys is called.
    pub fn r#add_wrapping_key(
        &self,
        mut wrapping_key_id: &[u8; 16],
        mut key: &[u8],
    ) -> fidl::client::QueryResponseFut<
        CryptManagementAddWrappingKeyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        CryptManagementProxyInterface::r#add_wrapping_key(self, wrapping_key_id, key)
    }

    /// Updates the key which will be used for wrapping keys (Crypt::CreateKey).  `purpose`
    /// describes which active key to modify.
    pub fn r#set_active_key(
        &self,
        mut purpose: KeyPurpose,
        mut wrapping_key_id: &[u8; 16],
    ) -> fidl::client::QueryResponseFut<
        CryptManagementSetActiveKeyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        CryptManagementProxyInterface::r#set_active_key(self, purpose, wrapping_key_id)
    }

    /// Forgets a wrapping key, preventing its use for future key-unwrapping.  All future calls to
    /// Crypt::UnwrapKeys with that wrapping key ID will fail.
    /// If either the data or metadata part of the key is active, an error is returned.
    pub fn r#forget_wrapping_key(
        &self,
        mut wrapping_key_id: &[u8; 16],
    ) -> fidl::client::QueryResponseFut<
        CryptManagementForgetWrappingKeyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        CryptManagementProxyInterface::r#forget_wrapping_key(self, wrapping_key_id)
    }
}

impl CryptManagementProxyInterface for CryptManagementProxy {
    type AddWrappingKeyResponseFut = fidl::client::QueryResponseFut<
        CryptManagementAddWrappingKeyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#add_wrapping_key(
        &self,
        mut wrapping_key_id: &[u8; 16],
        mut key: &[u8],
    ) -> Self::AddWrappingKeyResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<CryptManagementAddWrappingKeyResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x59a5076762318bf,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            CryptManagementAddWrappingKeyRequest,
            CryptManagementAddWrappingKeyResult,
        >(
            (wrapping_key_id, key,),
            0x59a5076762318bf,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetActiveKeyResponseFut = fidl::client::QueryResponseFut<
        CryptManagementSetActiveKeyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_active_key(
        &self,
        mut purpose: KeyPurpose,
        mut wrapping_key_id: &[u8; 16],
    ) -> Self::SetActiveKeyResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<CryptManagementSetActiveKeyResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5e81d600442f2872,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            CryptManagementSetActiveKeyRequest,
            CryptManagementSetActiveKeyResult,
        >(
            (purpose, wrapping_key_id,),
            0x5e81d600442f2872,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ForgetWrappingKeyResponseFut = fidl::client::QueryResponseFut<
        CryptManagementForgetWrappingKeyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#forget_wrapping_key(
        &self,
        mut wrapping_key_id: &[u8; 16],
    ) -> Self::ForgetWrappingKeyResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<CryptManagementForgetWrappingKeyResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x436d6d27696dfcf4,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            CryptManagementForgetWrappingKeyRequest,
            CryptManagementForgetWrappingKeyResult,
        >(
            (wrapping_key_id,),
            0x436d6d27696dfcf4,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for CryptManagementRequestStream {
    type Protocol = CryptManagementMarker;
    type ControlHandle = CryptManagementControlHandle;

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

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

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

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

impl futures::Stream for CryptManagementRequestStream {
    type Item = Result<CryptManagementRequest, 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 CryptManagementRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x59a5076762318bf => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            CryptManagementAddWrappingKeyRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<CryptManagementAddWrappingKeyRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            CryptManagementControlHandle { inner: this.inner.clone() };
                        Ok(CryptManagementRequest::AddWrappingKey {
                            wrapping_key_id: req.wrapping_key_id,
                            key: req.key,

                            responder: CryptManagementAddWrappingKeyResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5e81d600442f2872 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            CryptManagementSetActiveKeyRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<CryptManagementSetActiveKeyRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            CryptManagementControlHandle { inner: this.inner.clone() };
                        Ok(CryptManagementRequest::SetActiveKey {
                            purpose: req.purpose,
                            wrapping_key_id: req.wrapping_key_id,

                            responder: CryptManagementSetActiveKeyResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x436d6d27696dfcf4 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            CryptManagementForgetWrappingKeyRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<CryptManagementForgetWrappingKeyRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            CryptManagementControlHandle { inner: this.inner.clone() };
                        Ok(CryptManagementRequest::ForgetWrappingKey {
                            wrapping_key_id: req.wrapping_key_id,

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

#[derive(Debug)]
pub enum CryptManagementRequest {
    /// Adds a new wrapping key to the Crypt service.  The new key will immediately be available
    /// for unwrapping keys (Crypt::UnwrapKeys) but won't be used for wrapping keys until
    /// CryptManagement::SetActiveKeys is called.
    AddWrappingKey {
        wrapping_key_id: [u8; 16],
        key: Vec<u8>,
        responder: CryptManagementAddWrappingKeyResponder,
    },
    /// Updates the key which will be used for wrapping keys (Crypt::CreateKey).  `purpose`
    /// describes which active key to modify.
    SetActiveKey {
        purpose: KeyPurpose,
        wrapping_key_id: [u8; 16],
        responder: CryptManagementSetActiveKeyResponder,
    },
    /// Forgets a wrapping key, preventing its use for future key-unwrapping.  All future calls to
    /// Crypt::UnwrapKeys with that wrapping key ID will fail.
    /// If either the data or metadata part of the key is active, an error is returned.
    ForgetWrappingKey {
        wrapping_key_id: [u8; 16],
        responder: CryptManagementForgetWrappingKeyResponder,
    },
}

impl CryptManagementRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_add_wrapping_key(
        self,
    ) -> Option<([u8; 16], Vec<u8>, CryptManagementAddWrappingKeyResponder)> {
        if let CryptManagementRequest::AddWrappingKey { wrapping_key_id, key, responder } = self {
            Some((wrapping_key_id, key, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_active_key(
        self,
    ) -> Option<(KeyPurpose, [u8; 16], CryptManagementSetActiveKeyResponder)> {
        if let CryptManagementRequest::SetActiveKey { purpose, wrapping_key_id, responder } = self {
            Some((purpose, wrapping_key_id, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_forget_wrapping_key(
        self,
    ) -> Option<([u8; 16], CryptManagementForgetWrappingKeyResponder)> {
        if let CryptManagementRequest::ForgetWrappingKey { wrapping_key_id, responder } = self {
            Some((wrapping_key_id, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            CryptManagementRequest::AddWrappingKey { .. } => "add_wrapping_key",
            CryptManagementRequest::SetActiveKey { .. } => "set_active_key",
            CryptManagementRequest::ForgetWrappingKey { .. } => "forget_wrapping_key",
        }
    }
}

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

impl fidl::endpoints::ControlHandle for CryptManagementControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl CryptManagementControlHandle {}

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

/// Set the the channel to be shutdown (see [`CryptManagementControlHandle::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 CryptManagementAddWrappingKeyResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for CryptManagementAddWrappingKeyResponder {
    type ControlHandle = CryptManagementControlHandle;

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

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

/// Set the the channel to be shutdown (see [`CryptManagementControlHandle::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 CryptManagementSetActiveKeyResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for CryptManagementSetActiveKeyResponder {
    type ControlHandle = CryptManagementControlHandle;

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

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

/// Set the the channel to be shutdown (see [`CryptManagementControlHandle::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 CryptManagementForgetWrappingKeyResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for CryptManagementForgetWrappingKeyResponder {
    type ControlHandle = CryptManagementControlHandle;

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

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

impl fidl::endpoints::ProtocolMarker for DebugMarker {
    type Proxy = DebugProxy;
    type RequestStream = DebugRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = DebugSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.fxfs.Debug";
}
impl fidl::endpoints::DiscoverableProtocolMarker for DebugMarker {}
pub type DebugCompactResult = Result<(), i32>;
pub type DebugDeleteProfileResult = Result<(), i32>;
pub type DebugStopProfileTasksResult = Result<(), i32>;

pub trait DebugProxyInterface: Send + Sync {
    type CompactResponseFut: std::future::Future<Output = Result<DebugCompactResult, fidl::Error>>
        + Send;
    fn r#compact(&self) -> Self::CompactResponseFut;
    type DeleteProfileResponseFut: std::future::Future<Output = Result<DebugDeleteProfileResult, fidl::Error>>
        + Send;
    fn r#delete_profile(&self, volume: &str, profile: &str) -> Self::DeleteProfileResponseFut;
    type StopProfileTasksResponseFut: std::future::Future<Output = Result<DebugStopProfileTasksResult, fidl::Error>>
        + Send;
    fn r#stop_profile_tasks(&self) -> Self::StopProfileTasksResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct DebugSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for DebugSynchronousProxy {
    type Proxy = DebugProxy;
    type Protocol = DebugMarker;

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

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

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

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

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

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<DebugEvent, fidl::Error> {
        DebugEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Forces a compaction.
    pub fn r#compact(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DebugCompactResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (),
            0x6553eb197306e489,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Deletes a recorded profile from a volume. Fails if the volume isn't mounted or there is
    /// active profile recording or replay.
    pub fn r#delete_profile(
        &self,
        mut volume: &str,
        mut profile: &str,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DebugDeleteProfileResult, fidl::Error> {
        let _response = self.client.send_query::<
            DebugDeleteProfileRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (volume, profile,),
            0x54d9d4c9cf300a1e,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Stops all profile recording and replay activity. Ongoing recordings are completed and
    /// persisted.
    pub fn r#stop_profile_tasks(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DebugStopProfileTasksResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (),
            0x1657b945dd629177,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for DebugProxy {
    type Protocol = DebugMarker;

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

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

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

impl DebugProxy {
    /// Create a new Proxy for fuchsia.fxfs/Debug.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <DebugMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> DebugEventStream {
        DebugEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Forces a compaction.
    pub fn r#compact(
        &self,
    ) -> fidl::client::QueryResponseFut<
        DebugCompactResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DebugProxyInterface::r#compact(self)
    }

    /// Deletes a recorded profile from a volume. Fails if the volume isn't mounted or there is
    /// active profile recording or replay.
    pub fn r#delete_profile(
        &self,
        mut volume: &str,
        mut profile: &str,
    ) -> fidl::client::QueryResponseFut<
        DebugDeleteProfileResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DebugProxyInterface::r#delete_profile(self, volume, profile)
    }

    /// Stops all profile recording and replay activity. Ongoing recordings are completed and
    /// persisted.
    pub fn r#stop_profile_tasks(
        &self,
    ) -> fidl::client::QueryResponseFut<
        DebugStopProfileTasksResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DebugProxyInterface::r#stop_profile_tasks(self)
    }
}

impl DebugProxyInterface for DebugProxy {
    type CompactResponseFut = fidl::client::QueryResponseFut<
        DebugCompactResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#compact(&self) -> Self::CompactResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DebugCompactResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6553eb197306e489,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, DebugCompactResult>(
            (),
            0x6553eb197306e489,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type DeleteProfileResponseFut = fidl::client::QueryResponseFut<
        DebugDeleteProfileResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#delete_profile(
        &self,
        mut volume: &str,
        mut profile: &str,
    ) -> Self::DeleteProfileResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DebugDeleteProfileResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x54d9d4c9cf300a1e,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<DebugDeleteProfileRequest, DebugDeleteProfileResult>(
            (volume, profile),
            0x54d9d4c9cf300a1e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for DebugRequestStream {
    type Protocol = DebugMarker;
    type ControlHandle = DebugControlHandle;

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

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

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

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

impl futures::Stream for DebugRequestStream {
    type Item = Result<DebugRequest, 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 DebugRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x6553eb197306e489 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DebugControlHandle { inner: this.inner.clone() };
                        Ok(DebugRequest::Compact {
                            responder: DebugCompactResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x54d9d4c9cf300a1e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DebugDeleteProfileRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DebugDeleteProfileRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DebugControlHandle { inner: this.inner.clone() };
                        Ok(DebugRequest::DeleteProfile {
                            volume: req.volume,
                            profile: req.profile,

                            responder: DebugDeleteProfileResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1657b945dd629177 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DebugControlHandle { inner: this.inner.clone() };
                        Ok(DebugRequest::StopProfileTasks {
                            responder: DebugStopProfileTasksResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name: <DebugMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// This is an internal protocol for on-device debugging and testing only.
/// See `ffx fxfs help` for more details.
#[derive(Debug)]
pub enum DebugRequest {
    /// Forces a compaction.
    Compact { responder: DebugCompactResponder },
    /// Deletes a recorded profile from a volume. Fails if the volume isn't mounted or there is
    /// active profile recording or replay.
    DeleteProfile { volume: String, profile: String, responder: DebugDeleteProfileResponder },
    /// Stops all profile recording and replay activity. Ongoing recordings are completed and
    /// persisted.
    StopProfileTasks { responder: DebugStopProfileTasksResponder },
}

impl DebugRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_compact(self) -> Option<(DebugCompactResponder)> {
        if let DebugRequest::Compact { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_delete_profile(self) -> Option<(String, String, DebugDeleteProfileResponder)> {
        if let DebugRequest::DeleteProfile { volume, profile, responder } = self {
            Some((volume, profile, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_stop_profile_tasks(self) -> Option<(DebugStopProfileTasksResponder)> {
        if let DebugRequest::StopProfileTasks { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            DebugRequest::Compact { .. } => "compact",
            DebugRequest::DeleteProfile { .. } => "delete_profile",
            DebugRequest::StopProfileTasks { .. } => "stop_profile_tasks",
        }
    }
}

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

impl fidl::endpoints::ControlHandle for DebugControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl DebugControlHandle {}

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

/// Set the the channel to be shutdown (see [`DebugControlHandle::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 DebugCompactResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DebugCompactResponder {
    type ControlHandle = DebugControlHandle;

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

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

/// Set the the channel to be shutdown (see [`DebugControlHandle::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 DebugDeleteProfileResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DebugDeleteProfileResponder {
    type ControlHandle = DebugControlHandle;

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

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

/// Set the the channel to be shutdown (see [`DebugControlHandle::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 DebugStopProfileTasksResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DebugStopProfileTasksResponder {
    type ControlHandle = DebugControlHandle;

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

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

impl fidl::endpoints::ProtocolMarker for FileBackedVolumeProviderMarker {
    type Proxy = FileBackedVolumeProviderProxy;
    type RequestStream = FileBackedVolumeProviderRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = FileBackedVolumeProviderSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.fxfs.FileBackedVolumeProvider";
}
impl fidl::endpoints::DiscoverableProtocolMarker for FileBackedVolumeProviderMarker {}

pub trait FileBackedVolumeProviderProxyInterface: Send + Sync {
    fn r#open(
        &self,
        parent_directory_token: fidl::Handle,
        name: &str,
        server_end: fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_block_volume::VolumeMarker>,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct FileBackedVolumeProviderSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for FileBackedVolumeProviderSynchronousProxy {
    type Proxy = FileBackedVolumeProviderProxy;
    type Protocol = FileBackedVolumeProviderMarker;

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

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

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

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

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

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<FileBackedVolumeProviderEvent, fidl::Error> {
        FileBackedVolumeProviderEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Opens a file as a block device and starts serving block requests.
    ///
    /// `name` must refer to an existing file in the directory represented by
    /// `parent_directory_token`.
    ///
    /// The block size of the device will match the underlying filesystem's block size.  If the
    /// file's size is not a multiple of the block size, the apparent size of the device will be
    /// rounded down.
    ///
    /// `parent_directory_token` is a token obtained via `fuchsia.io.Directory/GetToken`.  The
    /// directory connection must have the `MODIFY_DIRECTORY` right.
    ///
    /// Errors will be sent as an epitaph on `server_end`.
    pub fn r#open(
        &self,
        mut parent_directory_token: fidl::Handle,
        mut name: &str,
        mut server_end: fidl::endpoints::ServerEnd<
            fidl_fuchsia_hardware_block_volume::VolumeMarker,
        >,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FileBackedVolumeProviderOpenRequest>(
            (parent_directory_token, name, server_end),
            0x67120b9fc9f319ee,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for FileBackedVolumeProviderProxy {
    type Protocol = FileBackedVolumeProviderMarker;

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

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

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

impl FileBackedVolumeProviderProxy {
    /// Create a new Proxy for fuchsia.fxfs/FileBackedVolumeProvider.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <FileBackedVolumeProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> FileBackedVolumeProviderEventStream {
        FileBackedVolumeProviderEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Opens a file as a block device and starts serving block requests.
    ///
    /// `name` must refer to an existing file in the directory represented by
    /// `parent_directory_token`.
    ///
    /// The block size of the device will match the underlying filesystem's block size.  If the
    /// file's size is not a multiple of the block size, the apparent size of the device will be
    /// rounded down.
    ///
    /// `parent_directory_token` is a token obtained via `fuchsia.io.Directory/GetToken`.  The
    /// directory connection must have the `MODIFY_DIRECTORY` right.
    ///
    /// Errors will be sent as an epitaph on `server_end`.
    pub fn r#open(
        &self,
        mut parent_directory_token: fidl::Handle,
        mut name: &str,
        mut server_end: fidl::endpoints::ServerEnd<
            fidl_fuchsia_hardware_block_volume::VolumeMarker,
        >,
    ) -> Result<(), fidl::Error> {
        FileBackedVolumeProviderProxyInterface::r#open(
            self,
            parent_directory_token,
            name,
            server_end,
        )
    }
}

impl FileBackedVolumeProviderProxyInterface for FileBackedVolumeProviderProxy {
    fn r#open(
        &self,
        mut parent_directory_token: fidl::Handle,
        mut name: &str,
        mut server_end: fidl::endpoints::ServerEnd<
            fidl_fuchsia_hardware_block_volume::VolumeMarker,
        >,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FileBackedVolumeProviderOpenRequest>(
            (parent_directory_token, name, server_end),
            0x67120b9fc9f319ee,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for FileBackedVolumeProviderRequestStream {
    type Protocol = FileBackedVolumeProviderMarker;
    type ControlHandle = FileBackedVolumeProviderControlHandle;

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

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

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

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

impl futures::Stream for FileBackedVolumeProviderRequestStream {
    type Item = Result<FileBackedVolumeProviderRequest, 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 FileBackedVolumeProviderRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                0x67120b9fc9f319ee => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(FileBackedVolumeProviderOpenRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FileBackedVolumeProviderOpenRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = FileBackedVolumeProviderControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(FileBackedVolumeProviderRequest::Open {parent_directory_token: req.parent_directory_token,
name: req.name,
server_end: req.server_end,

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

/// A protocol to serve the Volume protocol on a file-backed device.
#[derive(Debug)]
pub enum FileBackedVolumeProviderRequest {
    /// Opens a file as a block device and starts serving block requests.
    ///
    /// `name` must refer to an existing file in the directory represented by
    /// `parent_directory_token`.
    ///
    /// The block size of the device will match the underlying filesystem's block size.  If the
    /// file's size is not a multiple of the block size, the apparent size of the device will be
    /// rounded down.
    ///
    /// `parent_directory_token` is a token obtained via `fuchsia.io.Directory/GetToken`.  The
    /// directory connection must have the `MODIFY_DIRECTORY` right.
    ///
    /// Errors will be sent as an epitaph on `server_end`.
    Open {
        parent_directory_token: fidl::Handle,
        name: String,
        server_end: fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_block_volume::VolumeMarker>,
        control_handle: FileBackedVolumeProviderControlHandle,
    },
}

impl FileBackedVolumeProviderRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_open(
        self,
    ) -> Option<(
        fidl::Handle,
        String,
        fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_block_volume::VolumeMarker>,
        FileBackedVolumeProviderControlHandle,
    )> {
        if let FileBackedVolumeProviderRequest::Open {
            parent_directory_token,
            name,
            server_end,
            control_handle,
        } = self
        {
            Some((parent_directory_token, name, server_end, control_handle))
        } else {
            None
        }
    }

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

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

impl fidl::endpoints::ControlHandle for FileBackedVolumeProviderControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl FileBackedVolumeProviderControlHandle {}

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

impl fidl::endpoints::ProtocolMarker for ProjectIdMarker {
    type Proxy = ProjectIdProxy;
    type RequestStream = ProjectIdRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ProjectIdSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.fxfs.ProjectId";
}
impl fidl::endpoints::DiscoverableProtocolMarker for ProjectIdMarker {}
pub type ProjectIdSetLimitResult = Result<(), i32>;
pub type ProjectIdClearResult = Result<(), i32>;
pub type ProjectIdSetForNodeResult = Result<(), i32>;
pub type ProjectIdGetForNodeResult = Result<u64, i32>;
pub type ProjectIdClearForNodeResult = Result<(), i32>;
pub type ProjectIdListResult = Result<(Vec<u64>, Option<Box<ProjectIterToken>>), i32>;
pub type ProjectIdInfoResult = Result<(BytesAndNodes, BytesAndNodes), i32>;

pub trait ProjectIdProxyInterface: Send + Sync {
    type SetLimitResponseFut: std::future::Future<Output = Result<ProjectIdSetLimitResult, fidl::Error>>
        + Send;
    fn r#set_limit(&self, project_id: u64, bytes: u64, nodes: u64) -> Self::SetLimitResponseFut;
    type ClearResponseFut: std::future::Future<Output = Result<ProjectIdClearResult, fidl::Error>>
        + Send;
    fn r#clear(&self, project_id: u64) -> Self::ClearResponseFut;
    type SetForNodeResponseFut: std::future::Future<Output = Result<ProjectIdSetForNodeResult, fidl::Error>>
        + Send;
    fn r#set_for_node(&self, node_id: u64, project_id: u64) -> Self::SetForNodeResponseFut;
    type GetForNodeResponseFut: std::future::Future<Output = Result<ProjectIdGetForNodeResult, fidl::Error>>
        + Send;
    fn r#get_for_node(&self, node_id: u64) -> Self::GetForNodeResponseFut;
    type ClearForNodeResponseFut: std::future::Future<Output = Result<ProjectIdClearForNodeResult, fidl::Error>>
        + Send;
    fn r#clear_for_node(&self, node_id: u64) -> Self::ClearForNodeResponseFut;
    type ListResponseFut: std::future::Future<Output = Result<ProjectIdListResult, fidl::Error>>
        + Send;
    fn r#list(&self, token: Option<&ProjectIterToken>) -> Self::ListResponseFut;
    type InfoResponseFut: std::future::Future<Output = Result<ProjectIdInfoResult, fidl::Error>>
        + Send;
    fn r#info(&self, project_id: u64) -> Self::InfoResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ProjectIdSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ProjectIdSynchronousProxy {
    type Proxy = ProjectIdProxy;
    type Protocol = ProjectIdMarker;

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

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

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

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

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

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<ProjectIdEvent, fidl::Error> {
        ProjectIdEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Set the limit in bytes and node count for an XFS project id. Setting limits lower than
    /// current usage is accepted but may in the future prevent further increases. Returns
    ///  ZX_ERR_OUT_OF_RANGE if `project_id` is set to zero.
    pub fn r#set_limit(
        &self,
        mut project_id: u64,
        mut bytes: u64,
        mut nodes: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ProjectIdSetLimitResult, fidl::Error> {
        let _response = self.client.send_query::<
            ProjectIdSetLimitRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (project_id, bytes, nodes,),
            0x20b0fc1e0413876f,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Stop tracking a project id. This will return  ZX_ERR_NOT_FOUND if the project isn't
    /// currently tracked. It will succeed even if the project is still in use more by one or more
    /// nodes.
    pub fn r#clear(
        &self,
        mut project_id: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ProjectIdClearResult, fidl::Error> {
        let _response = self.client.send_query::<
            ProjectIdClearRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (project_id,),
            0x165b5f1e707863c1,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Apply project id to a node_id from a GetAttrs call. This will return ZX_ERR_NOT_FOUND if
    /// node doesn't exist, and ZX_ERR_OUT_OF_RANGE if `project_id` is set to zero.
    pub fn r#set_for_node(
        &self,
        mut node_id: u64,
        mut project_id: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ProjectIdSetForNodeResult, fidl::Error> {
        let _response = self.client.send_query::<
            ProjectIdSetForNodeRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (node_id, project_id,),
            0x4d7a8442dc58324c,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get the project id based on a given node_id from a GetAttrs call.This will return
    /// ZX_ERR_NOT_FOUND if the node doesn't exist, and a `project_id` of zero if one is not
    /// currently applied.
    pub fn r#get_for_node(
        &self,
        mut node_id: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ProjectIdGetForNodeResult, fidl::Error> {
        let _response = self.client.send_query::<
            ProjectIdGetForNodeRequest,
            fidl::encoding::ResultType<ProjectIdGetForNodeResponse, i32>,
        >(
            (node_id,),
            0x644073bdf2542573,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.project_id))
    }

    /// Remove any project id marker for a given node_id from a GetAttrs call. This will return
    /// ZX_ERR_NOT_FOUND if the node doesn't exist, or success if the node is found to currently
    /// have no project id applied to it.
    pub fn r#clear_for_node(
        &self,
        mut node_id: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ProjectIdClearForNodeResult, fidl::Error> {
        let _response = self.client.send_query::<
            ProjectIdClearForNodeRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (node_id,),
            0x3f2ca287bbfe6a62,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Fetches project id numbers currently tracked with a limit or with non-zero usage from lowest
    /// to highest. If `token` is null, start at the beginning, if `token` is populated with a
    /// previously provided `next_token` the iteration continues where it left off. If there are
    /// more projects to be listed then `next_token` will be populated, otherwise it will be null.
    pub fn r#list(
        &self,
        mut token: Option<&ProjectIterToken>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ProjectIdListResult, fidl::Error> {
        let _response = self.client.send_query::<
            ProjectIdListRequest,
            fidl::encoding::ResultType<ProjectIdListResponse, i32>,
        >(
            (token,),
            0x5505f95a36d522cc,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| (x.entries, x.next_token)))
    }

    /// Looks up the limit and usage for a tracked `project_id`. If the `project_id` does not have
    /// a limit set, or non-zero usage it will return ZX_ERR_NOT_FOUND.
    pub fn r#info(
        &self,
        mut project_id: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ProjectIdInfoResult, fidl::Error> {
        let _response = self.client.send_query::<
            ProjectIdInfoRequest,
            fidl::encoding::ResultType<ProjectIdInfoResponse, i32>,
        >(
            (project_id,),
            0x51b47743c9e2d1ab,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| (x.limit, x.usage)))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for ProjectIdProxy {
    type Protocol = ProjectIdMarker;

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

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

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

impl ProjectIdProxy {
    /// Create a new Proxy for fuchsia.fxfs/ProjectId.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <ProjectIdMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> ProjectIdEventStream {
        ProjectIdEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Set the limit in bytes and node count for an XFS project id. Setting limits lower than
    /// current usage is accepted but may in the future prevent further increases. Returns
    ///  ZX_ERR_OUT_OF_RANGE if `project_id` is set to zero.
    pub fn r#set_limit(
        &self,
        mut project_id: u64,
        mut bytes: u64,
        mut nodes: u64,
    ) -> fidl::client::QueryResponseFut<
        ProjectIdSetLimitResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ProjectIdProxyInterface::r#set_limit(self, project_id, bytes, nodes)
    }

    /// Stop tracking a project id. This will return  ZX_ERR_NOT_FOUND if the project isn't
    /// currently tracked. It will succeed even if the project is still in use more by one or more
    /// nodes.
    pub fn r#clear(
        &self,
        mut project_id: u64,
    ) -> fidl::client::QueryResponseFut<
        ProjectIdClearResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ProjectIdProxyInterface::r#clear(self, project_id)
    }

    /// Apply project id to a node_id from a GetAttrs call. This will return ZX_ERR_NOT_FOUND if
    /// node doesn't exist, and ZX_ERR_OUT_OF_RANGE if `project_id` is set to zero.
    pub fn r#set_for_node(
        &self,
        mut node_id: u64,
        mut project_id: u64,
    ) -> fidl::client::QueryResponseFut<
        ProjectIdSetForNodeResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ProjectIdProxyInterface::r#set_for_node(self, node_id, project_id)
    }

    /// Get the project id based on a given node_id from a GetAttrs call.This will return
    /// ZX_ERR_NOT_FOUND if the node doesn't exist, and a `project_id` of zero if one is not
    /// currently applied.
    pub fn r#get_for_node(
        &self,
        mut node_id: u64,
    ) -> fidl::client::QueryResponseFut<
        ProjectIdGetForNodeResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ProjectIdProxyInterface::r#get_for_node(self, node_id)
    }

    /// Remove any project id marker for a given node_id from a GetAttrs call. This will return
    /// ZX_ERR_NOT_FOUND if the node doesn't exist, or success if the node is found to currently
    /// have no project id applied to it.
    pub fn r#clear_for_node(
        &self,
        mut node_id: u64,
    ) -> fidl::client::QueryResponseFut<
        ProjectIdClearForNodeResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ProjectIdProxyInterface::r#clear_for_node(self, node_id)
    }

    /// Fetches project id numbers currently tracked with a limit or with non-zero usage from lowest
    /// to highest. If `token` is null, start at the beginning, if `token` is populated with a
    /// previously provided `next_token` the iteration continues where it left off. If there are
    /// more projects to be listed then `next_token` will be populated, otherwise it will be null.
    pub fn r#list(
        &self,
        mut token: Option<&ProjectIterToken>,
    ) -> fidl::client::QueryResponseFut<
        ProjectIdListResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ProjectIdProxyInterface::r#list(self, token)
    }

    /// Looks up the limit and usage for a tracked `project_id`. If the `project_id` does not have
    /// a limit set, or non-zero usage it will return ZX_ERR_NOT_FOUND.
    pub fn r#info(
        &self,
        mut project_id: u64,
    ) -> fidl::client::QueryResponseFut<
        ProjectIdInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ProjectIdProxyInterface::r#info(self, project_id)
    }
}

impl ProjectIdProxyInterface for ProjectIdProxy {
    type SetLimitResponseFut = fidl::client::QueryResponseFut<
        ProjectIdSetLimitResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_limit(
        &self,
        mut project_id: u64,
        mut bytes: u64,
        mut nodes: u64,
    ) -> Self::SetLimitResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ProjectIdSetLimitResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x20b0fc1e0413876f,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<ProjectIdSetLimitRequest, ProjectIdSetLimitResult>(
            (project_id, bytes, nodes),
            0x20b0fc1e0413876f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ClearResponseFut = fidl::client::QueryResponseFut<
        ProjectIdClearResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#clear(&self, mut project_id: u64) -> Self::ClearResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ProjectIdClearResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x165b5f1e707863c1,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<ProjectIdClearRequest, ProjectIdClearResult>(
            (project_id,),
            0x165b5f1e707863c1,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetForNodeResponseFut = fidl::client::QueryResponseFut<
        ProjectIdSetForNodeResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_for_node(&self, mut node_id: u64, mut project_id: u64) -> Self::SetForNodeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ProjectIdSetForNodeResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4d7a8442dc58324c,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<ProjectIdSetForNodeRequest, ProjectIdSetForNodeResult>(
            (node_id, project_id),
            0x4d7a8442dc58324c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetForNodeResponseFut = fidl::client::QueryResponseFut<
        ProjectIdGetForNodeResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_for_node(&self, mut node_id: u64) -> Self::GetForNodeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ProjectIdGetForNodeResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<ProjectIdGetForNodeResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x644073bdf2542573,
            >(_buf?)?;
            Ok(_response.map(|x| x.project_id))
        }
        self.client.send_query_and_decode::<ProjectIdGetForNodeRequest, ProjectIdGetForNodeResult>(
            (node_id,),
            0x644073bdf2542573,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ClearForNodeResponseFut = fidl::client::QueryResponseFut<
        ProjectIdClearForNodeResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#clear_for_node(&self, mut node_id: u64) -> Self::ClearForNodeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ProjectIdClearForNodeResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3f2ca287bbfe6a62,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<ProjectIdClearForNodeRequest, ProjectIdClearForNodeResult>(
                (node_id,),
                0x3f2ca287bbfe6a62,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type ListResponseFut = fidl::client::QueryResponseFut<
        ProjectIdListResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#list(&self, mut token: Option<&ProjectIterToken>) -> Self::ListResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ProjectIdListResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<ProjectIdListResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5505f95a36d522cc,
            >(_buf?)?;
            Ok(_response.map(|x| (x.entries, x.next_token)))
        }
        self.client.send_query_and_decode::<ProjectIdListRequest, ProjectIdListResult>(
            (token,),
            0x5505f95a36d522cc,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type InfoResponseFut = fidl::client::QueryResponseFut<
        ProjectIdInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#info(&self, mut project_id: u64) -> Self::InfoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ProjectIdInfoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<ProjectIdInfoResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x51b47743c9e2d1ab,
            >(_buf?)?;
            Ok(_response.map(|x| (x.limit, x.usage)))
        }
        self.client.send_query_and_decode::<ProjectIdInfoRequest, ProjectIdInfoResult>(
            (project_id,),
            0x51b47743c9e2d1ab,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for ProjectIdRequestStream {
    type Protocol = ProjectIdMarker;
    type ControlHandle = ProjectIdControlHandle;

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

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

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

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

impl futures::Stream for ProjectIdRequestStream {
    type Item = Result<ProjectIdRequest, 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 ProjectIdRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x20b0fc1e0413876f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ProjectIdSetLimitRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ProjectIdSetLimitRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ProjectIdControlHandle { inner: this.inner.clone() };
                        Ok(ProjectIdRequest::SetLimit {
                            project_id: req.project_id,
                            bytes: req.bytes,
                            nodes: req.nodes,

                            responder: ProjectIdSetLimitResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x165b5f1e707863c1 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ProjectIdClearRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ProjectIdClearRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ProjectIdControlHandle { inner: this.inner.clone() };
                        Ok(ProjectIdRequest::Clear {
                            project_id: req.project_id,

                            responder: ProjectIdClearResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4d7a8442dc58324c => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ProjectIdSetForNodeRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ProjectIdSetForNodeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ProjectIdControlHandle { inner: this.inner.clone() };
                        Ok(ProjectIdRequest::SetForNode {
                            node_id: req.node_id,
                            project_id: req.project_id,

                            responder: ProjectIdSetForNodeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x644073bdf2542573 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ProjectIdGetForNodeRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ProjectIdGetForNodeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ProjectIdControlHandle { inner: this.inner.clone() };
                        Ok(ProjectIdRequest::GetForNode {
                            node_id: req.node_id,

                            responder: ProjectIdGetForNodeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3f2ca287bbfe6a62 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ProjectIdClearForNodeRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ProjectIdClearForNodeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ProjectIdControlHandle { inner: this.inner.clone() };
                        Ok(ProjectIdRequest::ClearForNode {
                            node_id: req.node_id,

                            responder: ProjectIdClearForNodeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5505f95a36d522cc => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ProjectIdListRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ProjectIdListRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ProjectIdControlHandle { inner: this.inner.clone() };
                        Ok(ProjectIdRequest::List {
                            token: req.token,

                            responder: ProjectIdListResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x51b47743c9e2d1ab => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ProjectIdInfoRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ProjectIdInfoRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ProjectIdControlHandle { inner: this.inner.clone() };
                        Ok(ProjectIdRequest::Info {
                            project_id: req.project_id,

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

#[derive(Debug)]
pub enum ProjectIdRequest {
    /// Set the limit in bytes and node count for an XFS project id. Setting limits lower than
    /// current usage is accepted but may in the future prevent further increases. Returns
    ///  ZX_ERR_OUT_OF_RANGE if `project_id` is set to zero.
    SetLimit { project_id: u64, bytes: u64, nodes: u64, responder: ProjectIdSetLimitResponder },
    /// Stop tracking a project id. This will return  ZX_ERR_NOT_FOUND if the project isn't
    /// currently tracked. It will succeed even if the project is still in use more by one or more
    /// nodes.
    Clear { project_id: u64, responder: ProjectIdClearResponder },
    /// Apply project id to a node_id from a GetAttrs call. This will return ZX_ERR_NOT_FOUND if
    /// node doesn't exist, and ZX_ERR_OUT_OF_RANGE if `project_id` is set to zero.
    SetForNode { node_id: u64, project_id: u64, responder: ProjectIdSetForNodeResponder },
    /// Get the project id based on a given node_id from a GetAttrs call.This will return
    /// ZX_ERR_NOT_FOUND if the node doesn't exist, and a `project_id` of zero if one is not
    /// currently applied.
    GetForNode { node_id: u64, responder: ProjectIdGetForNodeResponder },
    /// Remove any project id marker for a given node_id from a GetAttrs call. This will return
    /// ZX_ERR_NOT_FOUND if the node doesn't exist, or success if the node is found to currently
    /// have no project id applied to it.
    ClearForNode { node_id: u64, responder: ProjectIdClearForNodeResponder },
    /// Fetches project id numbers currently tracked with a limit or with non-zero usage from lowest
    /// to highest. If `token` is null, start at the beginning, if `token` is populated with a
    /// previously provided `next_token` the iteration continues where it left off. If there are
    /// more projects to be listed then `next_token` will be populated, otherwise it will be null.
    List { token: Option<Box<ProjectIterToken>>, responder: ProjectIdListResponder },
    /// Looks up the limit and usage for a tracked `project_id`. If the `project_id` does not have
    /// a limit set, or non-zero usage it will return ZX_ERR_NOT_FOUND.
    Info { project_id: u64, responder: ProjectIdInfoResponder },
}

impl ProjectIdRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_set_limit(self) -> Option<(u64, u64, u64, ProjectIdSetLimitResponder)> {
        if let ProjectIdRequest::SetLimit { project_id, bytes, nodes, responder } = self {
            Some((project_id, bytes, nodes, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_clear(self) -> Option<(u64, ProjectIdClearResponder)> {
        if let ProjectIdRequest::Clear { project_id, responder } = self {
            Some((project_id, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_for_node(self) -> Option<(u64, u64, ProjectIdSetForNodeResponder)> {
        if let ProjectIdRequest::SetForNode { node_id, project_id, responder } = self {
            Some((node_id, project_id, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_for_node(self) -> Option<(u64, ProjectIdGetForNodeResponder)> {
        if let ProjectIdRequest::GetForNode { node_id, responder } = self {
            Some((node_id, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_clear_for_node(self) -> Option<(u64, ProjectIdClearForNodeResponder)> {
        if let ProjectIdRequest::ClearForNode { node_id, responder } = self {
            Some((node_id, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_list(self) -> Option<(Option<Box<ProjectIterToken>>, ProjectIdListResponder)> {
        if let ProjectIdRequest::List { token, responder } = self {
            Some((token, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_info(self) -> Option<(u64, ProjectIdInfoResponder)> {
        if let ProjectIdRequest::Info { project_id, responder } = self {
            Some((project_id, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            ProjectIdRequest::SetLimit { .. } => "set_limit",
            ProjectIdRequest::Clear { .. } => "clear",
            ProjectIdRequest::SetForNode { .. } => "set_for_node",
            ProjectIdRequest::GetForNode { .. } => "get_for_node",
            ProjectIdRequest::ClearForNode { .. } => "clear_for_node",
            ProjectIdRequest::List { .. } => "list",
            ProjectIdRequest::Info { .. } => "info",
        }
    }
}

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

impl fidl::endpoints::ControlHandle for ProjectIdControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl ProjectIdControlHandle {}

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

/// Set the the channel to be shutdown (see [`ProjectIdControlHandle::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 ProjectIdSetLimitResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for ProjectIdSetLimitResponder {
    type ControlHandle = ProjectIdControlHandle;

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

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

/// Set the the channel to be shutdown (see [`ProjectIdControlHandle::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 ProjectIdClearResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for ProjectIdClearResponder {
    type ControlHandle = ProjectIdControlHandle;

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

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

/// Set the the channel to be shutdown (see [`ProjectIdControlHandle::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 ProjectIdSetForNodeResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for ProjectIdSetForNodeResponder {
    type ControlHandle = ProjectIdControlHandle;

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

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

/// Set the the channel to be shutdown (see [`ProjectIdControlHandle::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 ProjectIdGetForNodeResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for ProjectIdGetForNodeResponder {
    type ControlHandle = ProjectIdControlHandle;

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

    fn send_raw(&self, mut result: Result<u64, i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<ProjectIdGetForNodeResponse, i32>>(
                result.map(|project_id| (project_id,)),
                self.tx_id,
                0x644073bdf2542573,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

/// Set the the channel to be shutdown (see [`ProjectIdControlHandle::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 ProjectIdClearForNodeResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for ProjectIdClearForNodeResponder {
    type ControlHandle = ProjectIdControlHandle;

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

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

/// Set the the channel to be shutdown (see [`ProjectIdControlHandle::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 ProjectIdListResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for ProjectIdListResponder {
    type ControlHandle = ProjectIdControlHandle;

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

    fn send_raw(
        &self,
        mut result: Result<(&[u64], Option<&ProjectIterToken>), i32>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<ProjectIdListResponse, i32>>(
            result,
            self.tx_id,
            0x5505f95a36d522cc,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`ProjectIdControlHandle::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 ProjectIdInfoResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for ProjectIdInfoResponder {
    type ControlHandle = ProjectIdControlHandle;

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

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

mod internal {
    use super::*;

    impl fidl::encoding::ResourceTypeMarker for BlobCreatorCreateResponse {
        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 BlobCreatorCreateResponse {
        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<
            BlobCreatorCreateResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut BlobCreatorCreateResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<BlobCreatorCreateResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<BlobCreatorCreateResponse, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<BlobWriterMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.writer),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<BlobWriterMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            BlobCreatorCreateResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<BlobCreatorCreateResponse>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for BlobCreatorCreateResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                writer: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<BlobWriterMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for BlobReaderGetVmoResponse {
        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 BlobReaderGetVmoResponse {
        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<
            BlobReaderGetVmoResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut BlobReaderGetVmoResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<BlobReaderGetVmoResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                BlobReaderGetVmoResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<fidl::encoding::HandleType<
                    fidl::Vmo,
                    { fidl::ObjectType::VMO.into_raw() },
                    2147483648,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.vmo
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::Vmo,
                    { fidl::ObjectType::VMO.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            BlobReaderGetVmoResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<BlobReaderGetVmoResponse>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for BlobReaderGetVmoResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                vmo: fidl::new_empty!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for BlobVolumeWriterWriteRequest {
        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 BlobVolumeWriterWriteRequest {
        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<
            BlobVolumeWriterWriteRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut BlobVolumeWriterWriteRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<BlobVolumeWriterWriteRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                BlobVolumeWriterWriteRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<fidl::encoding::HandleType<
                    fidl::Vmo,
                    { fidl::ObjectType::VMO.into_raw() },
                    2147483648,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.payload
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::Vmo,
                    { fidl::ObjectType::VMO.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            BlobVolumeWriterWriteRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<BlobVolumeWriterWriteRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for BlobVolumeWriterWriteRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                payload: fidl::new_empty!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for BlobWriterGetVmoResponse {
        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 BlobWriterGetVmoResponse {
        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<
            BlobWriterGetVmoResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut BlobWriterGetVmoResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<BlobWriterGetVmoResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                BlobWriterGetVmoResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<fidl::encoding::HandleType<
                    fidl::Vmo,
                    { fidl::ObjectType::VMO.into_raw() },
                    2147483648,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.vmo
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::Vmo,
                    { fidl::ObjectType::VMO.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            BlobWriterGetVmoResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<BlobWriterGetVmoResponse>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for BlobWriterGetVmoResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                vmo: fidl::new_empty!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            FileBackedVolumeProviderOpenRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut FileBackedVolumeProviderOpenRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FileBackedVolumeProviderOpenRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                FileBackedVolumeProviderOpenRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <fidl::encoding::HandleType<
                        fidl::Handle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.parent_directory_token,
                    ),
                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.name,
                    ),
                    <fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<
                            fidl_fuchsia_hardware_block_volume::VolumeMarker,
                        >,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.server_end
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::Handle,
                    { fidl::ObjectType::NONE.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::BoundedString<255>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T2: fidl::encoding::Encode<
                fidl::encoding::Endpoint<
                    fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_block_volume::VolumeMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            FileBackedVolumeProviderOpenRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FileBackedVolumeProviderOpenRequest>(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);
            }
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(24);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            self.2.encode(encoder, offset + 24, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for FileBackedVolumeProviderOpenRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                parent_directory_token: fidl::new_empty!(fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
                name: fidl::new_empty!(
                    fidl::encoding::BoundedString<255>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                server_end: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<
                            fidl_fuchsia_hardware_block_volume::VolumeMarker,
                        >,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(24) };
            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 + 24 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.parent_directory_token, decoder, offset + 0, _depth)?;
            fidl::decode!(
                fidl::encoding::BoundedString<255>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.name,
                decoder,
                offset + 8,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<
                    fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_block_volume::VolumeMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.server_end,
                decoder,
                offset + 24,
                _depth
            )?;
            Ok(())
        }
    }
}