fdomain_fuchsia_fxfs/

fdomain_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 fdomain_client::fidl::{ControlHandle as _, FDomainFlexibleIntoResult as _, Responder as _};
use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
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: fdomain_client::fidl::ClientEnd<BlobWriterMarker>,
}

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

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

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

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

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct FileBackedVolumeProviderOpenRequest {
    pub parent_directory_token: fdomain_client::NullableHandle,
    pub name: String,
    pub server_end: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_storage_block::BlockMarker>,
}

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

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

impl fdomain_client::fidl::ProtocolMarker for BlobCreatorMarker {
    type Proxy = BlobCreatorProxy;
    type RequestStream = BlobCreatorRequestStream;

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

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;
    type NeedsOverwriteResponseFut: std::future::Future<Output = Result<BlobCreatorNeedsOverwriteResult, fidl::Error>>
        + Send;
    fn r#needs_overwrite(&self, blob_hash: &[u8; 32]) -> Self::NeedsOverwriteResponseFut;
}

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

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

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

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

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

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

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> 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,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        BlobCreatorProxyInterface::r#create(self, hash, allow_existing)
    }

    /// Given the hash of a blob, returns true if it should be overwritten using Create with
    /// `allow_existing` set to true. Must respond the same as `BlobReader.GetVmo` in terms of
    /// existence checks, responding ZX_ERR_NOT_FOUND under the same conditions.
    pub fn r#needs_overwrite(
        &self,
        mut blob_hash: &[u8; 32],
    ) -> fidl::client::QueryResponseFut<
        BlobCreatorNeedsOverwriteResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        BlobCreatorProxyInterface::r#needs_overwrite(self, blob_hash)
    }
}

impl BlobCreatorProxyInterface for BlobCreatorProxy {
    type CreateResponseFut = fidl::client::QueryResponseFut<
        BlobCreatorCreateResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#create(&self, mut hash: &[u8; 32], mut allow_existing: bool) -> Self::CreateResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BlobCreatorCreateResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<BlobCreatorCreateResponse, CreateBlobError>,
                fdomain_client::fidl::FDomainResourceDialect,
                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,
        )
    }

    type NeedsOverwriteResponseFut = fidl::client::QueryResponseFut<
        BlobCreatorNeedsOverwriteResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#needs_overwrite(&self, mut blob_hash: &[u8; 32]) -> Self::NeedsOverwriteResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BlobCreatorNeedsOverwriteResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<BlobCreatorNeedsOverwriteResponse, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x512e347a6be3e426,
            >(_buf?)?;
            Ok(_response.map(|x| x.needs_overwrite))
        }
        self.client.send_query_and_decode::<
            BlobCreatorNeedsOverwriteRequest,
            BlobCreatorNeedsOverwriteResult,
        >(
            (blob_hash,),
            0x512e347a6be3e426,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

pub struct BlobCreatorEventStream {
    event_receiver: fidl::client::EventReceiver<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

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

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

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

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

impl futures::Stream for 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::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(e))) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x4288fe720cca70d7 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BlobCreatorCreateRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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,
                            },
                        })
                    }
                    0x512e347a6be3e426 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BlobCreatorNeedsOverwriteRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<BlobCreatorNeedsOverwriteRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BlobCreatorControlHandle { inner: this.inner.clone() };
                        Ok(BlobCreatorRequest::NeedsOverwrite {
                            blob_hash: req.blob_hash,

                            responder: BlobCreatorNeedsOverwriteResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <BlobCreatorMarker as fdomain_client::fidl::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 },
    /// Given the hash of a blob, returns true if it should be overwritten using Create with
    /// `allow_existing` set to true. Must respond the same as `BlobReader.GetVmo` in terms of
    /// existence checks, responding ZX_ERR_NOT_FOUND under the same conditions.
    NeedsOverwrite { blob_hash: [u8; 32], responder: BlobCreatorNeedsOverwriteResponder },
}

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
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_needs_overwrite(self) -> Option<([u8; 32], BlobCreatorNeedsOverwriteResponder)> {
        if let BlobCreatorRequest::NeedsOverwrite { 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 {
            BlobCreatorRequest::Create { .. } => "create",
            BlobCreatorRequest::NeedsOverwrite { .. } => "needs_overwrite",
        }
    }
}

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

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

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

    fn send_raw(
        &self,
        mut result: Result<fdomain_client::fidl::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(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BlobCreatorNeedsOverwriteResponder {
    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 BlobCreatorNeedsOverwriteResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

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

    fn send_raw(&self, mut result: Result<bool, i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<BlobCreatorNeedsOverwriteResponse, i32>>(
                result.map(|needs_overwrite| (needs_overwrite,)),
                self.tx_id,
                0x512e347a6be3e426,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

impl fdomain_client::fidl::ProtocolMarker for BlobReaderMarker {
    type Proxy = BlobReaderProxy;
    type RequestStream = BlobReaderRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.fxfs.BlobReader";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for BlobReaderMarker {}
pub type BlobReaderGetVmoResult = Result<fdomain_client::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, Clone)]
pub struct BlobReaderProxy {
    client: fidl::client::Client<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> 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,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        BlobReaderProxyInterface::r#get_vmo(self, blob_hash)
    }
}

impl BlobReaderProxyInterface for BlobReaderProxy {
    type GetVmoResponseFut = fidl::client::QueryResponseFut<
        BlobReaderGetVmoResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_vmo(&self, mut blob_hash: &[u8; 32]) -> Self::GetVmoResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BlobReaderGetVmoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<BlobReaderGetVmoResponse, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                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<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

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

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

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

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

impl futures::Stream for 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::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(e))) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x2fa72823ef7f11f4 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BlobReaderGetVmoRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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 fdomain_client::fidl::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<fdomain_client::fidl::FDomainResourceDialect>>,
}

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

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

    fn send_raw(&self, mut result: Result<fdomain_client::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 BlobWriterMarker;

impl fdomain_client::fidl::ProtocolMarker for BlobWriterMarker {
    type Proxy = BlobWriterProxy;
    type RequestStream = BlobWriterRequestStream;

    const DEBUG_NAME: &'static str = "(anonymous) BlobWriter";
}
pub type BlobWriterGetVmoResult = Result<fdomain_client::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, Clone)]
pub struct BlobWriterProxy {
    client: fidl::client::Client<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> 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,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        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,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        BlobWriterProxyInterface::r#bytes_ready(self, bytes_written)
    }
}

impl BlobWriterProxyInterface for BlobWriterProxy {
    type GetVmoResponseFut = fidl::client::QueryResponseFut<
        BlobWriterGetVmoResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_vmo(&self, mut size: u64) -> Self::GetVmoResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BlobWriterGetVmoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<BlobWriterGetVmoResponse, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                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,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#bytes_ready(&self, mut bytes_written: u64) -> Self::BytesReadyResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect 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>,
                fdomain_client::fidl::FDomainResourceDialect,
                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<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

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

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

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

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

impl futures::Stream for 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::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(e))) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x50c8988b12b6f893 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BlobWriterGetVmoRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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 fdomain_client::fidl::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<fdomain_client::fidl::FDomainResourceDialect>>,
}

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

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

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

    const DEBUG_NAME: &'static str = "fuchsia.fxfs.Crypt";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for CryptMarker {}
pub type CryptCreateKeyResult = Result<([u8; 16], Vec<u8>, Vec<u8>), i32>;
pub type CryptCreateKeyWithIdResult = Result<(WrappedKey, 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],
        object_type: ObjectType,
    ) -> 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, Clone)]
pub struct CryptProxy {
    client: fidl::client::Client<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> 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.
    /// TODO(https://fxbug.dev/445189846): Add an `object_type` field to support inline encryption.
    pub fn r#create_key(
        &self,
        mut owner: u64,
        mut purpose: KeyPurpose,
    ) -> fidl::client::QueryResponseFut<
        CryptCreateKeyResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        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],
        mut object_type: ObjectType,
    ) -> fidl::client::QueryResponseFut<
        CryptCreateKeyWithIdResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        CryptProxyInterface::r#create_key_with_id(self, owner, wrapping_key_id, object_type)
    }

    /// 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.
    /// ZX_ERR_UNAVAILABLE is returned if the key is known but cannot be unwrapped (e.g. it is
    /// locked).
    /// ZX_ERR_NOT_FOUND is returned if the key is not known. In some cases, implementations are
    /// unable to tell the difference between the two, in which case, ZX_ERR_UNAVAILABLE is
    /// returned.
    pub fn r#unwrap_key(
        &self,
        mut owner: u64,
        mut wrapped_key: &WrappedKey,
    ) -> fidl::client::QueryResponseFut<
        CryptUnwrapKeyResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        CryptProxyInterface::r#unwrap_key(self, owner, wrapped_key)
    }
}

impl CryptProxyInterface for CryptProxy {
    type CreateKeyResponseFut = fidl::client::QueryResponseFut<
        CryptCreateKeyResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#create_key(&self, mut owner: u64, mut purpose: KeyPurpose) -> Self::CreateKeyResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<CryptCreateKeyResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<CryptCreateKeyResponse, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                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,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#create_key_with_id(
        &self,
        mut owner: u64,
        mut wrapping_key_id: &[u8; 16],
        mut object_type: ObjectType,
    ) -> Self::CreateKeyWithIdResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<CryptCreateKeyWithIdResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<CryptCreateKeyWithIdResponse, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x21e8076688700b50,
            >(_buf?)?;
            Ok(_response.map(|x| (x.wrapped_key, x.unwrapped_key)))
        }
        self.client
            .send_query_and_decode::<CryptCreateKeyWithIdRequest, CryptCreateKeyWithIdResult>(
                (owner, wrapping_key_id, object_type),
                0x21e8076688700b50,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type UnwrapKeyResponseFut = fidl::client::QueryResponseFut<
        CryptUnwrapKeyResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#unwrap_key(
        &self,
        mut owner: u64,
        mut wrapped_key: &WrappedKey,
    ) -> Self::UnwrapKeyResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<CryptUnwrapKeyResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<CryptUnwrapKeyResponse, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                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<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

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

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

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

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

impl futures::Stream for 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::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(e))) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x6ec69b3aee7fdbba => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            CryptCreateKeyRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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,
                            object_type: req.object_type,

                            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,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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 fdomain_client::fidl::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.
    /// TODO(https://fxbug.dev/445189846): Add an `object_type` field to support inline encryption.
    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],
        object_type: ObjectType,
        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.
    /// ZX_ERR_UNAVAILABLE is returned if the key is known but cannot be unwrapped (e.g. it is
    /// locked).
    /// ZX_ERR_NOT_FOUND is returned if the key is not known. In some cases, implementations are
    /// unable to tell the difference between the two, in which case, ZX_ERR_UNAVAILABLE is
    /// returned.
    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], ObjectType, CryptCreateKeyWithIdResponder)> {
        if let CryptRequest::CreateKeyWithId { owner, wrapping_key_id, object_type, responder } =
            self
        {
            Some((owner, wrapping_key_id, object_type, 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<fdomain_client::fidl::FDomainResourceDialect>>,
}

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

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

    fn send_raw(&self, mut result: Result<(&WrappedKey, &[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 fdomain_client::fidl::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 fdomain_client::fidl::ProtocolMarker for CryptManagementMarker {
    type Proxy = CryptManagementProxy;
    type RequestStream = CryptManagementRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.fxfs.CryptManagement";
}
impl fdomain_client::fidl::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, Clone)]
pub struct CryptManagementProxy {
    client: fidl::client::Client<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> 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,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        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,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        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,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        CryptManagementProxyInterface::r#forget_wrapping_key(self, wrapping_key_id)
    }
}

impl CryptManagementProxyInterface for CryptManagementProxy {
    type AddWrappingKeyResponseFut = fidl::client::QueryResponseFut<
        CryptManagementAddWrappingKeyResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#add_wrapping_key(
        &self,
        mut wrapping_key_id: &[u8; 16],
        mut key: &[u8],
    ) -> Self::AddWrappingKeyResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect 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>,
                fdomain_client::fidl::FDomainResourceDialect,
                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,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#set_active_key(
        &self,
        mut purpose: KeyPurpose,
        mut wrapping_key_id: &[u8; 16],
    ) -> Self::SetActiveKeyResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect 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>,
                fdomain_client::fidl::FDomainResourceDialect,
                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,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#forget_wrapping_key(
        &self,
        mut wrapping_key_id: &[u8; 16],
    ) -> Self::ForgetWrappingKeyResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect 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>,
                fdomain_client::fidl::FDomainResourceDialect,
                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<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

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

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

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

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

impl futures::Stream for 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::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(e))) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

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

                std::task::Poll::Ready(Some(match header.ordinal {
                0x59a5076762318bf => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(CryptManagementAddWrappingKeyRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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 fdomain_client::fidl::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<fdomain_client::fidl::FDomainResourceDialect>>,
}

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

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 fdomain_client::fidl::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 fdomain_client::fidl::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 fdomain_client::fidl::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 fdomain_client::fidl::ProtocolMarker for DebugMarker {
    type Proxy = DebugProxy;
    type RequestStream = DebugRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.fxfs.Debug";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for DebugMarker {}
pub type DebugCompactResult = Result<(), i32>;
pub type DebugDeleteProfileResult = Result<(), i32>;
pub type DebugRecordAndReplayProfileResult = Result<(), i32>;
pub type DebugReplayXorRecordProfileResult = Result<(), i32>;
pub type DebugStopProfileTasksResult = Result<(), i32>;
pub type DebugClearCachesResult = 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 RecordAndReplayProfileResponseFut: std::future::Future<Output = Result<DebugRecordAndReplayProfileResult, fidl::Error>>
        + Send;
    fn r#record_and_replay_profile(
        &self,
        volume: Option<&str>,
        profile: &str,
        duration_secs: u32,
    ) -> Self::RecordAndReplayProfileResponseFut;
    type ReplayXorRecordProfileResponseFut: std::future::Future<Output = Result<DebugReplayXorRecordProfileResult, fidl::Error>>
        + Send;
    fn r#replay_xor_record_profile(
        &self,
        volume: &str,
        profile: &str,
        duration_secs: u32,
    ) -> Self::ReplayXorRecordProfileResponseFut;
    type StopProfileTasksResponseFut: std::future::Future<Output = Result<DebugStopProfileTasksResult, fidl::Error>>
        + Send;
    fn r#stop_profile_tasks(&self) -> Self::StopProfileTasksResponseFut;
    type ClearCachesResponseFut: std::future::Future<Output = Result<DebugClearCachesResult, fidl::Error>>
        + Send;
    fn r#clear_caches(&self) -> Self::ClearCachesResponseFut;
}

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

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

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

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

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

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

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

    /// Forces a compaction.
    pub fn r#compact(
        &self,
    ) -> fidl::client::QueryResponseFut<
        DebugCompactResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        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,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        DebugProxyInterface::r#delete_profile(self, volume, profile)
    }

    /// Begins recording a profile for a named volume for up to the given duration in seconds. If a
    /// profile already exists under the given name then it will begin replaying it as well. Fails
    /// if the volume isn't mounted or there is active profile recording or replay on the volume.
    /// Page faults for objects that do not get opened by a caller during the recording period will
    /// will be filtered out of the profile.
    ///
    /// This "record-while-replaying" strategy is meant to support boot-profiling in an environment
    /// where we don't explicitly know when the system has updated. By recording during replay and
    /// filtering objects without open events, Fxfs drops dead/replaced objects to refresh the
    /// profile.
    pub fn r#record_and_replay_profile(
        &self,
        mut volume: Option<&str>,
        mut profile: &str,
        mut duration_secs: u32,
    ) -> fidl::client::QueryResponseFut<
        DebugRecordAndReplayProfileResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        DebugProxyInterface::r#record_and_replay_profile(self, volume, profile, duration_secs)
    }

    /// Replays a profile if one exists, and only records if one does not exist. Fails if the volume
    /// isn't mounted or there is active profile recording or replay on the volume.
    ///
    /// This profile method is meant to support app launch profiling. These profiles do not filter
    /// entries based on Open events since outside of the boot process objects may already be opened
    /// or cached in overlays like Starnix.
    pub fn r#replay_xor_record_profile(
        &self,
        mut volume: &str,
        mut profile: &str,
        mut duration_secs: u32,
    ) -> fidl::client::QueryResponseFut<
        DebugReplayXorRecordProfileResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        DebugProxyInterface::r#replay_xor_record_profile(self, volume, profile, duration_secs)
    }

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

    /// Clears the directory entry cache (dirent cache) for all volumes. This drops the strong
    /// references held by the cache to filesystem nodes (files and directories). If these nodes
    /// are not currently open elsewhere, they will be dropped, freeing their associated resources
    /// (including VMOs). Subsequent access to these paths will force Fxfs to recreate the nodes.
    /// Note that this does not clear other internal caches (e.g., CachingObjectHandle's caches
    /// used for LSM tree layers).
    pub fn r#clear_caches(
        &self,
    ) -> fidl::client::QueryResponseFut<
        DebugClearCachesResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        DebugProxyInterface::r#clear_caches(self)
    }
}

impl DebugProxyInterface for DebugProxy {
    type CompactResponseFut = fidl::client::QueryResponseFut<
        DebugCompactResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#compact(&self) -> Self::CompactResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect 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>,
                fdomain_client::fidl::FDomainResourceDialect,
                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,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#delete_profile(
        &self,
        mut volume: &str,
        mut profile: &str,
    ) -> Self::DeleteProfileResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect 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>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x54d9d4c9cf300a1e,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<DebugDeleteProfileRequest, DebugDeleteProfileResult>(
            (volume, profile),
            0x54d9d4c9cf300a1e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type RecordAndReplayProfileResponseFut = fidl::client::QueryResponseFut<
        DebugRecordAndReplayProfileResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#record_and_replay_profile(
        &self,
        mut volume: Option<&str>,
        mut profile: &str,
        mut duration_secs: u32,
    ) -> Self::RecordAndReplayProfileResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DebugRecordAndReplayProfileResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x3973943f9b3a9010,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            DebugRecordAndReplayProfileRequest,
            DebugRecordAndReplayProfileResult,
        >(
            (volume, profile, duration_secs,),
            0x3973943f9b3a9010,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ReplayXorRecordProfileResponseFut = fidl::client::QueryResponseFut<
        DebugReplayXorRecordProfileResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#replay_xor_record_profile(
        &self,
        mut volume: &str,
        mut profile: &str,
        mut duration_secs: u32,
    ) -> Self::ReplayXorRecordProfileResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DebugReplayXorRecordProfileResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x301678a1cebeef20,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            DebugReplayXorRecordProfileRequest,
            DebugReplayXorRecordProfileResult,
        >(
            (volume, profile, duration_secs,),
            0x301678a1cebeef20,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type StopProfileTasksResponseFut = fidl::client::QueryResponseFut<
        DebugStopProfileTasksResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#stop_profile_tasks(&self) -> Self::StopProfileTasksResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect 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>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x1657b945dd629177,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, DebugStopProfileTasksResult>(
                (),
                0x1657b945dd629177,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

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

pub struct DebugEventStream {
    event_receiver: fidl::client::EventReceiver<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

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

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

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

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

impl futures::Stream for 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::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(e))) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x6553eb197306e489 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = 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,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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,
                            },
                        })
                    }
                    0x3973943f9b3a9010 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DebugRecordAndReplayProfileRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<DebugRecordAndReplayProfileRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DebugControlHandle { inner: this.inner.clone() };
                        Ok(DebugRequest::RecordAndReplayProfile {
                            volume: req.volume,
                            profile: req.profile,
                            duration_secs: req.duration_secs,

                            responder: DebugRecordAndReplayProfileResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x301678a1cebeef20 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DebugReplayXorRecordProfileRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<DebugReplayXorRecordProfileRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DebugControlHandle { inner: this.inner.clone() };
                        Ok(DebugRequest::ReplayXorRecordProfile {
                            volume: req.volume,
                            profile: req.profile,
                            duration_secs: req.duration_secs,

                            responder: DebugReplayXorRecordProfileResponder {
                                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,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DebugControlHandle { inner: this.inner.clone() };
                        Ok(DebugRequest::StopProfileTasks {
                            responder: DebugStopProfileTasksResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x539de2a4580de767 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DebugControlHandle { inner: this.inner.clone() };
                        Ok(DebugRequest::ClearCaches {
                            responder: DebugClearCachesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <DebugMarker as fdomain_client::fidl::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 },
    /// Begins recording a profile for a named volume for up to the given duration in seconds. If a
    /// profile already exists under the given name then it will begin replaying it as well. Fails
    /// if the volume isn't mounted or there is active profile recording or replay on the volume.
    /// Page faults for objects that do not get opened by a caller during the recording period will
    /// will be filtered out of the profile.
    ///
    /// This "record-while-replaying" strategy is meant to support boot-profiling in an environment
    /// where we don't explicitly know when the system has updated. By recording during replay and
    /// filtering objects without open events, Fxfs drops dead/replaced objects to refresh the
    /// profile.
    RecordAndReplayProfile {
        volume: Option<String>,
        profile: String,
        duration_secs: u32,
        responder: DebugRecordAndReplayProfileResponder,
    },
    /// Replays a profile if one exists, and only records if one does not exist. Fails if the volume
    /// isn't mounted or there is active profile recording or replay on the volume.
    ///
    /// This profile method is meant to support app launch profiling. These profiles do not filter
    /// entries based on Open events since outside of the boot process objects may already be opened
    /// or cached in overlays like Starnix.
    ReplayXorRecordProfile {
        volume: String,
        profile: String,
        duration_secs: u32,
        responder: DebugReplayXorRecordProfileResponder,
    },
    /// Stops all profile recording and replay activity. Ongoing recordings are completed and
    /// persisted.
    StopProfileTasks { responder: DebugStopProfileTasksResponder },
    /// Clears the directory entry cache (dirent cache) for all volumes. This drops the strong
    /// references held by the cache to filesystem nodes (files and directories). If these nodes
    /// are not currently open elsewhere, they will be dropped, freeing their associated resources
    /// (including VMOs). Subsequent access to these paths will force Fxfs to recreate the nodes.
    /// Note that this does not clear other internal caches (e.g., CachingObjectHandle's caches
    /// used for LSM tree layers).
    ClearCaches { responder: DebugClearCachesResponder },
}

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_record_and_replay_profile(
        self,
    ) -> Option<(Option<String>, String, u32, DebugRecordAndReplayProfileResponder)> {
        if let DebugRequest::RecordAndReplayProfile { volume, profile, duration_secs, responder } =
            self
        {
            Some((volume, profile, duration_secs, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_replay_xor_record_profile(
        self,
    ) -> Option<(String, String, u32, DebugReplayXorRecordProfileResponder)> {
        if let DebugRequest::ReplayXorRecordProfile { volume, profile, duration_secs, responder } =
            self
        {
            Some((volume, profile, duration_secs, 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
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_clear_caches(self) -> Option<(DebugClearCachesResponder)> {
        if let DebugRequest::ClearCaches { 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::RecordAndReplayProfile { .. } => "record_and_replay_profile",
            DebugRequest::ReplayXorRecordProfile { .. } => "replay_xor_record_profile",
            DebugRequest::StopProfileTasks { .. } => "stop_profile_tasks",
            DebugRequest::ClearCaches { .. } => "clear_caches",
        }
    }
}

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

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

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 fdomain_client::fidl::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 fdomain_client::fidl::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 DebugRecordAndReplayProfileResponder {
    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 DebugRecordAndReplayProfileResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for DebugRecordAndReplayProfileResponder {
    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 DebugRecordAndReplayProfileResponder {
    /// 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,
                0x3973943f9b3a9010,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DebugReplayXorRecordProfileResponder {
    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 DebugReplayXorRecordProfileResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for DebugReplayXorRecordProfileResponder {
    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 DebugReplayXorRecordProfileResponder {
    /// 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,
                0x301678a1cebeef20,
                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 fdomain_client::fidl::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(),
            )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DebugClearCachesResponder {
    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 DebugClearCachesResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for DebugClearCachesResponder {
    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 DebugClearCachesResponder {
    /// 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,
                0x539de2a4580de767,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

impl fdomain_client::fidl::ProtocolMarker for FileBackedVolumeProviderMarker {
    type Proxy = FileBackedVolumeProviderProxy;
    type RequestStream = FileBackedVolumeProviderRequestStream;

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

pub trait FileBackedVolumeProviderProxyInterface: Send + Sync {
    fn r#open(
        &self,
        parent_directory_token: fdomain_client::NullableHandle,
        name: &str,
        server_end: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_storage_block::BlockMarker>,
    ) -> Result<(), fidl::Error>;
}

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

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

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

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

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

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

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> 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: fdomain_client::NullableHandle,
        mut name: &str,
        mut server_end: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_storage_block::BlockMarker>,
    ) -> 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: fdomain_client::NullableHandle,
        mut name: &str,
        mut server_end: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_storage_block::BlockMarker>,
    ) -> 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<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

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

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

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

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

impl futures::Stream for 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::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(e))) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

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

                std::task::Poll::Ready(Some(match header.ordinal {
                0x67120b9fc9f319ee => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(FileBackedVolumeProviderOpenRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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 fdomain_client::fidl::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: fdomain_client::NullableHandle,
        name: String,
        server_end: fdomain_client::fidl::ServerEnd<fdomain_fuchsia_storage_block::BlockMarker>,
        control_handle: FileBackedVolumeProviderControlHandle,
    },
}

impl FileBackedVolumeProviderRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_open(
        self,
    ) -> Option<(
        fdomain_client::NullableHandle,
        String,
        fdomain_client::fidl::ServerEnd<fdomain_fuchsia_storage_block::BlockMarker>,
        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<fdomain_client::fidl::FDomainResourceDialect>>,
}

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

impl FileBackedVolumeProviderControlHandle {}

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

impl fdomain_client::fidl::ProtocolMarker for ProjectIdMarker {
    type Proxy = ProjectIdProxy;
    type RequestStream = ProjectIdRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.fxfs.ProjectId";
}
impl fdomain_client::fidl::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, Clone)]
pub struct ProjectIdProxy {
    client: fidl::client::Client<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> 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,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        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,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        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,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        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,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        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,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        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,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        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,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        ProjectIdProxyInterface::r#info(self, project_id)
    }
}

impl ProjectIdProxyInterface for ProjectIdProxy {
    type SetLimitResponseFut = fidl::client::QueryResponseFut<
        ProjectIdSetLimitResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#set_limit(
        &self,
        mut project_id: u64,
        mut bytes: u64,
        mut nodes: u64,
    ) -> Self::SetLimitResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect 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>,
                fdomain_client::fidl::FDomainResourceDialect,
                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,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#clear(&self, mut project_id: u64) -> Self::ClearResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect 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>,
                fdomain_client::fidl::FDomainResourceDialect,
                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,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#set_for_node(&self, mut node_id: u64, mut project_id: u64) -> Self::SetForNodeResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect 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>,
                fdomain_client::fidl::FDomainResourceDialect,
                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,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_for_node(&self, mut node_id: u64) -> Self::GetForNodeResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ProjectIdGetForNodeResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<ProjectIdGetForNodeResponse, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                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,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#clear_for_node(&self, mut node_id: u64) -> Self::ClearForNodeResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect 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>,
                fdomain_client::fidl::FDomainResourceDialect,
                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,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#list(&self, mut token: Option<&ProjectIterToken>) -> Self::ListResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ProjectIdListResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<ProjectIdListResponse, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                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,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#info(&self, mut project_id: u64) -> Self::InfoResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ProjectIdInfoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<ProjectIdInfoResponse, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                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<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

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

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

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

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

impl futures::Stream for 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::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(e))) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x20b0fc1e0413876f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ProjectIdSetLimitRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::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 fdomain_client::fidl::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<fdomain_client::fidl::FDomainResourceDialect>>,
}

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

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 fdomain_client::fidl::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 fdomain_client::fidl::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 fdomain_client::fidl::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 fdomain_client::fidl::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 fdomain_client::fidl::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 fdomain_client::fidl::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 fdomain_client::fidl::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(),
        )
    }
}

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

impl fdomain_client::fidl::ProtocolMarker for VolumeInstallerMarker {
    type Proxy = VolumeInstallerProxy;
    type RequestStream = VolumeInstallerRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.fxfs.VolumeInstaller";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for VolumeInstallerMarker {}
pub type VolumeInstallerInstallResult = Result<(), i32>;

pub trait VolumeInstallerProxyInterface: Send + Sync {
    type InstallResponseFut: std::future::Future<Output = Result<VolumeInstallerInstallResult, fidl::Error>>
        + Send;
    fn r#install(&self, src: &str, image_file: &str, dst: &str) -> Self::InstallResponseFut;
}

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

impl fdomain_client::fidl::Proxy for VolumeInstallerProxy {
    type Protocol = VolumeInstallerMarker;

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

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

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

impl VolumeInstallerProxy {
    /// Create a new Proxy for fuchsia.fxfs/VolumeInstaller.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name =
            <VolumeInstallerMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

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

    /// Using the partition image in `image_file` contained in the volume `src`, overwrites the
    /// volume `dst` with a volume of the same name from the image. On success, `src` will no longer
    /// exist. There must be no objects in `src` other than the image that contain extents.
    /// Neither `src` nor `dst` can be mounted or otherwise in-use.
    ///
    /// *WARNING*: This will delete the existing contents of `dst`.
    pub fn r#install(
        &self,
        mut src: &str,
        mut image_file: &str,
        mut dst: &str,
    ) -> fidl::client::QueryResponseFut<
        VolumeInstallerInstallResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        VolumeInstallerProxyInterface::r#install(self, src, image_file, dst)
    }
}

impl VolumeInstallerProxyInterface for VolumeInstallerProxy {
    type InstallResponseFut = fidl::client::QueryResponseFut<
        VolumeInstallerInstallResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#install(
        &self,
        mut src: &str,
        mut image_file: &str,
        mut dst: &str,
    ) -> Self::InstallResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<VolumeInstallerInstallResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x4c340be8a504ee1c,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<VolumeInstallerInstallRequest, VolumeInstallerInstallResult>(
                (src, image_file, dst),
                0x4c340be8a504ee1c,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }
}

pub struct VolumeInstallerEventStream {
    event_receiver: fidl::client::EventReceiver<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.fxfs/VolumeInstaller.
pub struct VolumeInstallerRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fdomain_client::fidl::RequestStream for VolumeInstallerRequestStream {
    type Protocol = VolumeInstallerMarker;
    type ControlHandle = VolumeInstallerControlHandle;

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                0x4c340be8a504ee1c => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(VolumeInstallerInstallRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<VolumeInstallerInstallRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = VolumeInstallerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(VolumeInstallerRequest::Install {src: req.src,
image_file: req.image_file,
dst: req.dst,

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

/// Allows installing a volume from an fxfs partition image.
#[derive(Debug)]
pub enum VolumeInstallerRequest {
    /// Using the partition image in `image_file` contained in the volume `src`, overwrites the
    /// volume `dst` with a volume of the same name from the image. On success, `src` will no longer
    /// exist. There must be no objects in `src` other than the image that contain extents.
    /// Neither `src` nor `dst` can be mounted or otherwise in-use.
    ///
    /// *WARNING*: This will delete the existing contents of `dst`.
    Install {
        src: String,
        image_file: String,
        dst: String,
        responder: VolumeInstallerInstallResponder,
    },
}

impl VolumeInstallerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_install(self) -> Option<(String, String, String, VolumeInstallerInstallResponder)> {
        if let VolumeInstallerRequest::Install { src, image_file, dst, responder } = self {
            Some((src, image_file, dst, responder))
        } else {
            None
        }
    }

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

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

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

impl VolumeInstallerControlHandle {}

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

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

impl fdomain_client::fidl::Responder for VolumeInstallerInstallResponder {
    type ControlHandle = VolumeInstallerControlHandle;

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

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Endpoint<fdomain_client::fidl::ClientEnd<BlobWriterMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
                &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,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut BlobReaderGetVmoResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<BlobReaderGetVmoResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                BlobReaderGetVmoResponse,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (<fidl::encoding::HandleType<
                    fdomain_client::Vmo,
                    { fidl::ObjectType::VMO.into_raw() },
                    2147483648,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.vmo
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fdomain_client::Vmo,
                    { fidl::ObjectType::VMO.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            BlobReaderGetVmoResponse,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fdomain_client::fidl::FDomainResourceDialect>
        for BlobReaderGetVmoResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                vmo: fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

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

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

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

    impl fidl::encoding::ResourceTypeMarker for 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,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut FileBackedVolumeProviderOpenRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FileBackedVolumeProviderOpenRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                FileBackedVolumeProviderOpenRequest,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (
                    <fidl::encoding::HandleType<
                        fdomain_client::NullableHandle,
                        { 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<
                        fdomain_client::fidl::ServerEnd<fdomain_fuchsia_storage_block::BlockMarker>,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.server_end
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fdomain_client::NullableHandle,
                    { fidl::ObjectType::NONE.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::BoundedString<255>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T2: fidl::encoding::Encode<
                fidl::encoding::Endpoint<
                    fdomain_client::fidl::ServerEnd<fdomain_fuchsia_storage_block::BlockMarker>,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            FileBackedVolumeProviderOpenRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fdomain_client::fidl::FDomainResourceDialect>
        for FileBackedVolumeProviderOpenRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                parent_directory_token: fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect),
                name: fidl::new_empty!(
                    fidl::encoding::BoundedString<255>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                server_end: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fdomain_client::fidl::ServerEnd<fdomain_fuchsia_storage_block::BlockMarker>,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

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