fidl_fuchsia_pkg/

fidl_fuchsia_pkg.rs

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

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

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct FontResolverResolveRequest {
    pub package_url: String,
    pub directory_request: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct NeededBlobsGetMissingBlobsRequest {
    pub iterator: fidl::endpoints::ServerEnd<BlobInfoIteratorMarker>,
}

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

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

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

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

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct PackageCacheBasePackageIndexRequest {
    pub iterator: fidl::endpoints::ServerEnd<PackageIndexIteratorMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct PackageCacheCachePackageIndexRequest {
    pub iterator: fidl::endpoints::ServerEnd<PackageIndexIteratorMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct PackageCacheGetRequest {
    pub meta_far_blob: BlobInfo,
    pub gc_protection: GcProtection,
    pub needed_blobs: fidl::endpoints::ServerEnd<NeededBlobsMarker>,
    pub dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct PackageCacheGetSubpackageRequest {
    pub superpackage: BlobId,
    pub subpackage: PackageUrl,
    pub dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct PackageCacheWriteBlobsRequest {
    pub needed_blobs: fidl::endpoints::ServerEnd<NeededBlobsMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct PackageResolverResolveRequest {
    pub package_url: String,
    pub dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct PackageResolverResolveWithContextRequest {
    pub package_url: String,
    pub context: ResolutionContext,
    pub dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RepositoryManagerListRequest {
    pub iterator: fidl::endpoints::ServerEnd<RepositoryIteratorMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RetainedBlobsReplaceRequest {
    pub iterator: fidl::endpoints::ClientEnd<BlobIdIteratorMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RetainedPackagesReplaceRequest {
    pub iterator: fidl::endpoints::ClientEnd<BlobIdIteratorMarker>,
}

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

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

impl fidl::endpoints::ProtocolMarker for AuthorityMarker {
    type Proxy = AuthorityProxy;
    type RequestStream = AuthorityRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = AuthoritySynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.pkg.Authority";
}
impl fidl::endpoints::DiscoverableProtocolMarker for AuthorityMarker {}
pub type AuthorityLookupResult = Result<(BlobId, String), AuthorityLookupError>;

pub trait AuthorityProxyInterface: Send + Sync {
    type LookupResponseFut: std::future::Future<Output = Result<AuthorityLookupResult, fidl::Error>>
        + Send;
    fn r#lookup(&self, package_url: &PackageUrl) -> Self::LookupResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct AuthoritySynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for AuthoritySynchronousProxy {
    type Proxy = AuthorityProxy;
    type Protocol = AuthorityMarker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl AuthoritySynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

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

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

    /// Get information about a package from this `Authority`.
    pub fn r#lookup(
        &self,
        mut package_url: &PackageUrl,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<AuthorityLookupResult, fidl::Error> {
        let _response = self.client.send_query::<
            AuthorityLookupRequest,
            fidl::encoding::ResultType<AuthorityLookupResponse, AuthorityLookupError>,
            AuthorityMarker,
        >(
            (package_url,),
            0x10c3e416b99c027c,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| (x.package_id, x.http_blob_dir)))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for AuthorityProxy {
    type Protocol = AuthorityMarker;

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

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

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

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

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

    /// Get information about a package from this `Authority`.
    pub fn r#lookup(
        &self,
        mut package_url: &PackageUrl,
    ) -> fidl::client::QueryResponseFut<
        AuthorityLookupResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        AuthorityProxyInterface::r#lookup(self, package_url)
    }
}

impl AuthorityProxyInterface for AuthorityProxy {
    type LookupResponseFut = fidl::client::QueryResponseFut<
        AuthorityLookupResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#lookup(&self, mut package_url: &PackageUrl) -> Self::LookupResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<AuthorityLookupResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<AuthorityLookupResponse, AuthorityLookupError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x10c3e416b99c027c,
            >(_buf?)?;
            Ok(_response.map(|x| (x.package_id, x.http_blob_dir)))
        }
        self.client.send_query_and_decode::<AuthorityLookupRequest, AuthorityLookupResult>(
            (package_url,),
            0x10c3e416b99c027c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for AuthorityRequestStream {
    type Protocol = AuthorityMarker;
    type ControlHandle = AuthorityControlHandle;

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x10c3e416b99c027c => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            AuthorityLookupRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AuthorityLookupRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = AuthorityControlHandle { inner: this.inner.clone() };
                        Ok(AuthorityRequest::Lookup {
                            package_url: req.package_url,

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

/// A mapping from package URLs [0] to package hashes and blob sources.
/// [0] https://fuchsia.dev/fuchsia-src/concepts/packages/package_url
#[derive(Debug)]
pub enum AuthorityRequest {
    /// Get information about a package from this `Authority`.
    Lookup { package_url: PackageUrl, responder: AuthorityLookupResponder },
}

impl AuthorityRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_lookup(self) -> Option<(PackageUrl, AuthorityLookupResponder)> {
        if let AuthorityRequest::Lookup { package_url, responder } = self {
            Some((package_url, responder))
        } else {
            None
        }
    }

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

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

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

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

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        self.inner.shutdown_with_epitaph(status)
    }

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

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

impl AuthorityControlHandle {}

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

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

impl fidl::endpoints::Responder for AuthorityLookupResponder {
    type ControlHandle = AuthorityControlHandle;

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

    fn send_raw(
        &self,
        mut result: Result<(&BlobId, &str), AuthorityLookupError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            AuthorityLookupResponse,
            AuthorityLookupError,
        >>(
            result,
            self.tx_id,
            0x10c3e416b99c027c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for BlobIdIteratorMarker {
    type Proxy = BlobIdIteratorProxy;
    type RequestStream = BlobIdIteratorRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = BlobIdIteratorSynchronousProxy;

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

pub trait BlobIdIteratorProxyInterface: Send + Sync {
    type NextResponseFut: std::future::Future<Output = Result<Vec<BlobId>, fidl::Error>> + Send;
    fn r#next(&self) -> Self::NextResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct BlobIdIteratorSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for BlobIdIteratorSynchronousProxy {
    type Proxy = BlobIdIteratorProxy;
    type Protocol = BlobIdIteratorMarker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl BlobIdIteratorSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

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

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

    /// Responds with the next chunk of blob IDs. When the iterator is
    /// exhausted, responds with an empty vector and closes the connection.
    ///
    /// - response `blobs` the next chunk of blob IDs.
    pub fn r#next(&self, ___deadline: zx::MonotonicInstant) -> Result<Vec<BlobId>, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            BlobIdIteratorNextResponse,
            BlobIdIteratorMarker,
        >(
            (),
            0x5eb0af0daeb8f537,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.blobs)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for BlobIdIteratorProxy {
    type Protocol = BlobIdIteratorMarker;

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

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

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

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

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

    /// Responds with the next chunk of blob IDs. When the iterator is
    /// exhausted, responds with an empty vector and closes the connection.
    ///
    /// - response `blobs` the next chunk of blob IDs.
    pub fn r#next(
        &self,
    ) -> fidl::client::QueryResponseFut<Vec<BlobId>, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        BlobIdIteratorProxyInterface::r#next(self)
    }
}

impl BlobIdIteratorProxyInterface for BlobIdIteratorProxy {
    type NextResponseFut =
        fidl::client::QueryResponseFut<Vec<BlobId>, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#next(&self) -> Self::NextResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<BlobId>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                BlobIdIteratorNextResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5eb0af0daeb8f537,
            >(_buf?)?;
            Ok(_response.blobs)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<BlobId>>(
            (),
            0x5eb0af0daeb8f537,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for BlobIdIteratorRequestStream {
    type Protocol = BlobIdIteratorMarker;
    type ControlHandle = BlobIdIteratorControlHandle;

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x5eb0af0daeb8f537 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BlobIdIteratorControlHandle { inner: this.inner.clone() };
                        Ok(BlobIdIteratorRequest::Next {
                            responder: BlobIdIteratorNextResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <BlobIdIteratorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// A chunked iterator of blob IDs, allowing transfer of more blob IDs that can
/// fit in a single FIDL message.
#[derive(Debug)]
pub enum BlobIdIteratorRequest {
    /// Responds with the next chunk of blob IDs. When the iterator is
    /// exhausted, responds with an empty vector and closes the connection.
    ///
    /// - response `blobs` the next chunk of blob IDs.
    Next { responder: BlobIdIteratorNextResponder },
}

impl BlobIdIteratorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_next(self) -> Option<(BlobIdIteratorNextResponder)> {
        if let BlobIdIteratorRequest::Next { responder } = self { Some((responder)) } else { None }
    }

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

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

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

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

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        self.inner.shutdown_with_epitaph(status)
    }

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

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

impl BlobIdIteratorControlHandle {}

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

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

impl fidl::endpoints::Responder for BlobIdIteratorNextResponder {
    type ControlHandle = BlobIdIteratorControlHandle;

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

    fn send_raw(&self, mut blobs: &[BlobId]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<BlobIdIteratorNextResponse>(
            (blobs,),
            self.tx_id,
            0x5eb0af0daeb8f537,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for BlobInfoIteratorMarker {
    type Proxy = BlobInfoIteratorProxy;
    type RequestStream = BlobInfoIteratorRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = BlobInfoIteratorSynchronousProxy;

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

pub trait BlobInfoIteratorProxyInterface: Send + Sync {
    type NextResponseFut: std::future::Future<Output = Result<Vec<BlobInfo>, fidl::Error>> + Send;
    fn r#next(&self) -> Self::NextResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct BlobInfoIteratorSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for BlobInfoIteratorSynchronousProxy {
    type Proxy = BlobInfoIteratorProxy;
    type Protocol = BlobInfoIteratorMarker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl BlobInfoIteratorSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

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

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

    /// Responds with the next chunk of [`BlobInfo`]s. When the iterator is
    /// exhausted, responds with an empty vector and closes the connection.
    ///
    /// - response `blobs` the next chunk of [`BlobInfo`]s.
    pub fn r#next(&self, ___deadline: zx::MonotonicInstant) -> Result<Vec<BlobInfo>, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            BlobInfoIteratorNextResponse,
            BlobInfoIteratorMarker,
        >(
            (),
            0x2b889489a59b6970,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.blobs)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for BlobInfoIteratorProxy {
    type Protocol = BlobInfoIteratorMarker;

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

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

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

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

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

    /// Responds with the next chunk of [`BlobInfo`]s. When the iterator is
    /// exhausted, responds with an empty vector and closes the connection.
    ///
    /// - response `blobs` the next chunk of [`BlobInfo`]s.
    pub fn r#next(
        &self,
    ) -> fidl::client::QueryResponseFut<Vec<BlobInfo>, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        BlobInfoIteratorProxyInterface::r#next(self)
    }
}

impl BlobInfoIteratorProxyInterface for BlobInfoIteratorProxy {
    type NextResponseFut = fidl::client::QueryResponseFut<
        Vec<BlobInfo>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#next(&self) -> Self::NextResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<BlobInfo>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                BlobInfoIteratorNextResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2b889489a59b6970,
            >(_buf?)?;
            Ok(_response.blobs)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<BlobInfo>>(
            (),
            0x2b889489a59b6970,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for BlobInfoIteratorRequestStream {
    type Protocol = BlobInfoIteratorMarker;
    type ControlHandle = BlobInfoIteratorControlHandle;

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x2b889489a59b6970 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BlobInfoIteratorControlHandle { inner: this.inner.clone() };
                        Ok(BlobInfoIteratorRequest::Next {
                            responder: BlobInfoIteratorNextResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <BlobInfoIteratorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// A chunked iterator of [`BlobInfo`], allowing transfer of more [`BlobInfo`]s
/// that can fit in a single FIDL message.
#[derive(Debug)]
pub enum BlobInfoIteratorRequest {
    /// Responds with the next chunk of [`BlobInfo`]s. When the iterator is
    /// exhausted, responds with an empty vector and closes the connection.
    ///
    /// - response `blobs` the next chunk of [`BlobInfo`]s.
    Next { responder: BlobInfoIteratorNextResponder },
}

impl BlobInfoIteratorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_next(self) -> Option<(BlobInfoIteratorNextResponder)> {
        if let BlobInfoIteratorRequest::Next { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

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

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

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

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

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        self.inner.shutdown_with_epitaph(status)
    }

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

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

impl BlobInfoIteratorControlHandle {}

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

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

impl fidl::endpoints::Responder for BlobInfoIteratorNextResponder {
    type ControlHandle = BlobInfoIteratorControlHandle;

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

    fn send_raw(&self, mut blobs: &[BlobInfo]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<BlobInfoIteratorNextResponse>(
            (blobs,),
            self.tx_id,
            0x2b889489a59b6970,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for CupMarker {
    type Proxy = CupProxy;
    type RequestStream = CupRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = CupSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.pkg.Cup";
}
impl fidl::endpoints::DiscoverableProtocolMarker for CupMarker {}
pub type CupWriteResult = Result<(), WriteError>;
pub type CupGetInfoResult = Result<(String, String), GetInfoError>;

pub trait CupProxyInterface: Send + Sync {
    type WriteResponseFut: std::future::Future<Output = Result<CupWriteResult, fidl::Error>> + Send;
    fn r#write(&self, url: &PackageUrl, cup: &CupData) -> Self::WriteResponseFut;
    type GetInfoResponseFut: std::future::Future<Output = Result<CupGetInfoResult, fidl::Error>>
        + Send;
    fn r#get_info(&self, url: &PackageUrl) -> Self::GetInfoResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct CupSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for CupSynchronousProxy {
    type Proxy = CupProxy;
    type Protocol = CupMarker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl CupSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

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

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

    /// Resolve the eager package given by the pinned package URL, and write the
    /// CUP data to storage.
    pub fn r#write(
        &self,
        mut url: &PackageUrl,
        mut cup: &CupData,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<CupWriteResult, fidl::Error> {
        let _response = self.client.send_query::<CupWriteRequest, fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            WriteError,
        >, CupMarker>(
            (url, cup),
            0x29f30e83bda39c37,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Returns the eager package version and channel of the given package URL.
    pub fn r#get_info(
        &self,
        mut url: &PackageUrl,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<CupGetInfoResult, fidl::Error> {
        let _response = self.client.send_query::<
            CupGetInfoRequest,
            fidl::encoding::ResultType<CupGetInfoResponse, GetInfoError>,
            CupMarker,
        >(
            (url,),
            0x5b2cedd887209b9c,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| (x.version, x.channel)))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for CupProxy {
    type Protocol = CupMarker;

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

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

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

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

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

    /// Resolve the eager package given by the pinned package URL, and write the
    /// CUP data to storage.
    pub fn r#write(
        &self,
        mut url: &PackageUrl,
        mut cup: &CupData,
    ) -> fidl::client::QueryResponseFut<CupWriteResult, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        CupProxyInterface::r#write(self, url, cup)
    }

    /// Returns the eager package version and channel of the given package URL.
    pub fn r#get_info(
        &self,
        mut url: &PackageUrl,
    ) -> fidl::client::QueryResponseFut<
        CupGetInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        CupProxyInterface::r#get_info(self, url)
    }
}

impl CupProxyInterface for CupProxy {
    type WriteResponseFut = fidl::client::QueryResponseFut<
        CupWriteResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#write(&self, mut url: &PackageUrl, mut cup: &CupData) -> Self::WriteResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<CupWriteResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, WriteError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x29f30e83bda39c37,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<CupWriteRequest, CupWriteResult>(
            (url, cup),
            0x29f30e83bda39c37,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetInfoResponseFut = fidl::client::QueryResponseFut<
        CupGetInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_info(&self, mut url: &PackageUrl) -> Self::GetInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<CupGetInfoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<CupGetInfoResponse, GetInfoError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5b2cedd887209b9c,
            >(_buf?)?;
            Ok(_response.map(|x| (x.version, x.channel)))
        }
        self.client.send_query_and_decode::<CupGetInfoRequest, CupGetInfoResult>(
            (url,),
            0x5b2cedd887209b9c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for CupRequestStream {
    type Protocol = CupMarker;
    type ControlHandle = CupControlHandle;

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x29f30e83bda39c37 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            CupWriteRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<CupWriteRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = CupControlHandle { inner: this.inner.clone() };
                        Ok(CupRequest::Write {
                            url: req.url,
                            cup: req.cup,

                            responder: CupWriteResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5b2cedd887209b9c => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            CupGetInfoRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<CupGetInfoRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = CupControlHandle { inner: this.inner.clone() };
                        Ok(CupRequest::GetInfo {
                            url: req.url,

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

/// This protocol gives access to persisted CUP data for eager packages in
/// pkg-resolver.
#[derive(Debug)]
pub enum CupRequest {
    /// Resolve the eager package given by the pinned package URL, and write the
    /// CUP data to storage.
    Write { url: PackageUrl, cup: CupData, responder: CupWriteResponder },
    /// Returns the eager package version and channel of the given package URL.
    GetInfo { url: PackageUrl, responder: CupGetInfoResponder },
}

impl CupRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_write(self) -> Option<(PackageUrl, CupData, CupWriteResponder)> {
        if let CupRequest::Write { url, cup, responder } = self {
            Some((url, cup, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_info(self) -> Option<(PackageUrl, CupGetInfoResponder)> {
        if let CupRequest::GetInfo { url, responder } = self {
            Some((url, responder))
        } else {
            None
        }
    }

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

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

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

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

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        self.inner.shutdown_with_epitaph(status)
    }

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

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

impl CupControlHandle {}

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

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

impl fidl::endpoints::Responder for CupWriteResponder {
    type ControlHandle = CupControlHandle;

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

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

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

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

impl fidl::endpoints::Responder for CupGetInfoResponder {
    type ControlHandle = CupControlHandle;

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

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

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

impl fidl::endpoints::ProtocolMarker for FontResolverMarker {
    type Proxy = FontResolverProxy;
    type RequestStream = FontResolverRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = FontResolverSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.pkg.FontResolver";
}
impl fidl::endpoints::DiscoverableProtocolMarker for FontResolverMarker {}
pub type FontResolverResolveResult = Result<(), i32>;

pub trait FontResolverProxyInterface: Send + Sync {
    type ResolveResponseFut: std::future::Future<Output = Result<FontResolverResolveResult, fidl::Error>>
        + Send;
    fn r#resolve(
        &self,
        package_url: &str,
        directory_request: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
    ) -> Self::ResolveResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct FontResolverSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for FontResolverSynchronousProxy {
    type Proxy = FontResolverProxy;
    type Protocol = FontResolverMarker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl FontResolverSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

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

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

    /// Populates or updates the cache of a font package, fetching it if it is not present on the
    /// local system.
    ///
    /// + request `package_url` the package URL of a font package.
    /// + request `directory_request` a request for a directory that will be resolved when the
    ///   package has been successfully cached. The directory should contain a single file,
    ///   corresponding to the asset filename. The client should retain the directory handle
    ///   for as long as needed to prevent the package from being evicted from cache.
    /// * error a zx_status value indicating failure. One of the following:
    ///     * `ZX_ERR_ACCESS_DENIED` if the resolver does not have permission to fetch a
    ///       package blob.
    ///     * `ZX_ERR_IO` if there is some other unspecified error during I/O.
    ///     * `ZX_ERR_NOT_FOUND` if the font package or a package blob does not exist, or is
    ///       not known to be a font package.
    ///     * `ZX_ERR_NO_SPACE` if there is no space available to store the package.
    ///     * `ZX_ERR_UNAVAILABLE` if the resolver is currently unable to fetch a package blob.
    pub fn r#resolve(
        &self,
        mut package_url: &str,
        mut directory_request: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<FontResolverResolveResult, fidl::Error> {
        let _response = self.client.send_query::<
            FontResolverResolveRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            FontResolverMarker,
        >(
            (package_url, directory_request,),
            0x159f60cc5ba432da,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for FontResolverProxy {
    type Protocol = FontResolverMarker;

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

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

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

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

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

    /// Populates or updates the cache of a font package, fetching it if it is not present on the
    /// local system.
    ///
    /// + request `package_url` the package URL of a font package.
    /// + request `directory_request` a request for a directory that will be resolved when the
    ///   package has been successfully cached. The directory should contain a single file,
    ///   corresponding to the asset filename. The client should retain the directory handle
    ///   for as long as needed to prevent the package from being evicted from cache.
    /// * error a zx_status value indicating failure. One of the following:
    ///     * `ZX_ERR_ACCESS_DENIED` if the resolver does not have permission to fetch a
    ///       package blob.
    ///     * `ZX_ERR_IO` if there is some other unspecified error during I/O.
    ///     * `ZX_ERR_NOT_FOUND` if the font package or a package blob does not exist, or is
    ///       not known to be a font package.
    ///     * `ZX_ERR_NO_SPACE` if there is no space available to store the package.
    ///     * `ZX_ERR_UNAVAILABLE` if the resolver is currently unable to fetch a package blob.
    pub fn r#resolve(
        &self,
        mut package_url: &str,
        mut directory_request: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
    ) -> fidl::client::QueryResponseFut<
        FontResolverResolveResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        FontResolverProxyInterface::r#resolve(self, package_url, directory_request)
    }
}

impl FontResolverProxyInterface for FontResolverProxy {
    type ResolveResponseFut = fidl::client::QueryResponseFut<
        FontResolverResolveResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#resolve(
        &self,
        mut package_url: &str,
        mut directory_request: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
    ) -> Self::ResolveResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<FontResolverResolveResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x159f60cc5ba432da,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<FontResolverResolveRequest, FontResolverResolveResult>(
            (package_url, directory_request),
            0x159f60cc5ba432da,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for FontResolverRequestStream {
    type Protocol = FontResolverMarker;
    type ControlHandle = FontResolverControlHandle;

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x159f60cc5ba432da => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            FontResolverResolveRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FontResolverResolveRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            FontResolverControlHandle { inner: this.inner.clone() };
                        Ok(FontResolverRequest::Resolve {
                            package_url: req.package_url,
                            directory_request: req.directory_request,

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

/// This resolves font packages from a registry.
///
/// This is intended to be implemented by package resolver components, and used
/// exclusively by fuchsia.fonts.Provider.
///
/// DEPRECATED. This is an interim solution, and will be revisited when Component Framework v2
/// becomes available and allows non-component packages and easier directory routing.
#[derive(Debug)]
pub enum FontResolverRequest {
    /// Populates or updates the cache of a font package, fetching it if it is not present on the
    /// local system.
    ///
    /// + request `package_url` the package URL of a font package.
    /// + request `directory_request` a request for a directory that will be resolved when the
    ///   package has been successfully cached. The directory should contain a single file,
    ///   corresponding to the asset filename. The client should retain the directory handle
    ///   for as long as needed to prevent the package from being evicted from cache.
    /// * error a zx_status value indicating failure. One of the following:
    ///     * `ZX_ERR_ACCESS_DENIED` if the resolver does not have permission to fetch a
    ///       package blob.
    ///     * `ZX_ERR_IO` if there is some other unspecified error during I/O.
    ///     * `ZX_ERR_NOT_FOUND` if the font package or a package blob does not exist, or is
    ///       not known to be a font package.
    ///     * `ZX_ERR_NO_SPACE` if there is no space available to store the package.
    ///     * `ZX_ERR_UNAVAILABLE` if the resolver is currently unable to fetch a package blob.
    Resolve {
        package_url: String,
        directory_request: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
        responder: FontResolverResolveResponder,
    },
}

impl FontResolverRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_resolve(
        self,
    ) -> Option<(
        String,
        fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
        FontResolverResolveResponder,
    )> {
        if let FontResolverRequest::Resolve { package_url, directory_request, responder } = self {
            Some((package_url, directory_request, responder))
        } else {
            None
        }
    }

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

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

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

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

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        self.inner.shutdown_with_epitaph(status)
    }

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

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

impl FontResolverControlHandle {}

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

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

impl fidl::endpoints::Responder for FontResolverResolveResponder {
    type ControlHandle = FontResolverControlHandle;

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

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

impl fidl::endpoints::ProtocolMarker for NeededBlobsMarker {
    type Proxy = NeededBlobsProxy;
    type RequestStream = NeededBlobsRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = NeededBlobsSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) NeededBlobs";
}
pub type NeededBlobsOpenMetaBlobResult =
    Result<Option<fidl::endpoints::ClientEnd<fidl_fuchsia_fxfs::BlobWriterMarker>>, OpenBlobError>;
pub type NeededBlobsOpenBlobResult =
    Result<Option<fidl::endpoints::ClientEnd<fidl_fuchsia_fxfs::BlobWriterMarker>>, OpenBlobError>;
pub type NeededBlobsBlobWrittenResult = Result<(), BlobWrittenError>;

pub trait NeededBlobsProxyInterface: Send + Sync {
    type OpenMetaBlobResponseFut: std::future::Future<Output = Result<NeededBlobsOpenMetaBlobResult, fidl::Error>>
        + Send;
    fn r#open_meta_blob(&self) -> Self::OpenMetaBlobResponseFut;
    fn r#get_missing_blobs(
        &self,
        iterator: fidl::endpoints::ServerEnd<BlobInfoIteratorMarker>,
    ) -> Result<(), fidl::Error>;
    type OpenBlobResponseFut: std::future::Future<Output = Result<NeededBlobsOpenBlobResult, fidl::Error>>
        + Send;
    fn r#open_blob(&self, blob_id: &BlobId, allow_existing: bool) -> Self::OpenBlobResponseFut;
    type BlobWrittenResponseFut: std::future::Future<Output = Result<NeededBlobsBlobWrittenResult, fidl::Error>>
        + Send;
    fn r#blob_written(&self, blob_id: &BlobId) -> Self::BlobWrittenResponseFut;
    type AbortResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#abort(&self) -> Self::AbortResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct NeededBlobsSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for NeededBlobsSynchronousProxy {
    type Proxy = NeededBlobsProxy;
    type Protocol = NeededBlobsMarker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl NeededBlobsSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

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

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

    /// Opens the package's metadata blob for writing. `GetMissingBlobs()`
    /// should not be called until writing the meta blob or this request
    /// responds with `false`.
    ///
    /// If the package was already cached, server will close the channel with a
    /// `ZX_OK` epitaph.
    ///
    /// - response `writer` is used to write the blob. If `writer` is absent,
    ///   the blob is already cached and so does not need to be written.
    /// * error an OpenBlobError indicating failure. Clients may retry this
    ///   request, though the server end may abort this cache operation on
    ///   errors it considers to be fatal.
    pub fn r#open_meta_blob(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<NeededBlobsOpenMetaBlobResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                NeededBlobsOpenMetaBlobResponse,
                OpenBlobError,
            >, NeededBlobsMarker>(
                (),
                0x42f385a58180f5fb,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.writer))
    }

    /// Returns an iterator of blobs that are not present on the system that
    /// must be written using the `OpenBlob` request before the package will be
    /// fully cached.
    ///
    /// Client should call `OpenMetaBlob`, and write it if needed, before
    /// calling `GetMissingBlobs`.
    ///
    /// A client should make this request no more than once per `NeededBlobs`
    /// connection. Once all blobs yielded by this iterator are written, the
    /// package open request will complete.
    ///
    /// New items may be added to the obtained `BlobInfoIterator` as the client
    /// calls `OpenBlob`, so, to guaranatee termination of the iterator, clients
    /// should call `OpenBlob` concurrently with reading the iterator.
    ///
    /// + request `iterator` a request for an iterator of [`BlobInfo`] of blobs
    ///   that the client should try to write.
    pub fn r#get_missing_blobs(
        &self,
        mut iterator: fidl::endpoints::ServerEnd<BlobInfoIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<NeededBlobsGetMissingBlobsRequest>(
            (iterator,),
            0x44eaf14fd56e7ae1,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Opens a blob for writing.
    ///
    /// + request `blob_id` the blob id describing this blob.
    /// + request `allow_existing` whether to open the blob even if it is already present.
    /// - response `writer` is used to write the blob. If `writer` is absent,
    ///   the blob is already cached and so does not need to be written.
    /// * error an OpenBlobError indicating failure. Clients may retry this
    ///   request, though the server end may abort this cache operation on
    ///   errors it considers to be fatal.
    pub fn r#open_blob(
        &self,
        mut blob_id: &BlobId,
        mut allow_existing: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<NeededBlobsOpenBlobResult, fidl::Error> {
        let _response = self.client.send_query::<
            NeededBlobsOpenBlobRequest,
            fidl::encoding::ResultType<NeededBlobsOpenBlobResponse, OpenBlobError>,
            NeededBlobsMarker,
        >(
            (blob_id, allow_existing,),
            0x67cd4c4cd10ea9e0,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.writer))
    }

    /// Indicates that a blob opened by `Open[Meta]Blob` has been successfully
    /// written.
    ///
    /// A client should call this once the blob has been fully written using
    /// the `writer` returned by `Open[Meta]Blob`.
    ///
    /// + request `blob_id` the blob id describing this blob.
    /// * error a BlobWrittenError indicating failure. Clients may retry the
    ///   `Open[Meta]Blob` request that prompted this call, though the server
    ///   end may abort this cache operation on errors it considers to be fatal.
    pub fn r#blob_written(
        &self,
        mut blob_id: &BlobId,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<NeededBlobsBlobWrittenResult, fidl::Error> {
        let _response = self.client.send_query::<
            NeededBlobsBlobWrittenRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, BlobWrittenError>,
            NeededBlobsMarker,
        >(
            (blob_id,),
            0x222f80ec77433f44,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Aborts this caching operation for the package.
    ///
    /// Any open blobs and any missing blobs iterator will be closed. Any `dir`
    /// provided to the associated [`PackageCache.Get`] request will also be
    /// closed. Once this request is acknowledged, this channel will be closed.
    ///
    /// Note, dropping this NeededBlobs channel without writing all needed blobs
    /// will also abort the package cache operation. However, this API provides
    /// the ability to wait for the operation to be torn down.
    pub fn r#abort(&self, ___deadline: zx::MonotonicInstant) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::EmptyPayload,
            NeededBlobsMarker,
        >(
            (),
            0x6fda8d5ebea74cbb,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for NeededBlobsProxy {
    type Protocol = NeededBlobsMarker;

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

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

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

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

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

    /// Opens the package's metadata blob for writing. `GetMissingBlobs()`
    /// should not be called until writing the meta blob or this request
    /// responds with `false`.
    ///
    /// If the package was already cached, server will close the channel with a
    /// `ZX_OK` epitaph.
    ///
    /// - response `writer` is used to write the blob. If `writer` is absent,
    ///   the blob is already cached and so does not need to be written.
    /// * error an OpenBlobError indicating failure. Clients may retry this
    ///   request, though the server end may abort this cache operation on
    ///   errors it considers to be fatal.
    pub fn r#open_meta_blob(
        &self,
    ) -> fidl::client::QueryResponseFut<
        NeededBlobsOpenMetaBlobResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        NeededBlobsProxyInterface::r#open_meta_blob(self)
    }

    /// Returns an iterator of blobs that are not present on the system that
    /// must be written using the `OpenBlob` request before the package will be
    /// fully cached.
    ///
    /// Client should call `OpenMetaBlob`, and write it if needed, before
    /// calling `GetMissingBlobs`.
    ///
    /// A client should make this request no more than once per `NeededBlobs`
    /// connection. Once all blobs yielded by this iterator are written, the
    /// package open request will complete.
    ///
    /// New items may be added to the obtained `BlobInfoIterator` as the client
    /// calls `OpenBlob`, so, to guaranatee termination of the iterator, clients
    /// should call `OpenBlob` concurrently with reading the iterator.
    ///
    /// + request `iterator` a request for an iterator of [`BlobInfo`] of blobs
    ///   that the client should try to write.
    pub fn r#get_missing_blobs(
        &self,
        mut iterator: fidl::endpoints::ServerEnd<BlobInfoIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        NeededBlobsProxyInterface::r#get_missing_blobs(self, iterator)
    }

    /// Opens a blob for writing.
    ///
    /// + request `blob_id` the blob id describing this blob.
    /// + request `allow_existing` whether to open the blob even if it is already present.
    /// - response `writer` is used to write the blob. If `writer` is absent,
    ///   the blob is already cached and so does not need to be written.
    /// * error an OpenBlobError indicating failure. Clients may retry this
    ///   request, though the server end may abort this cache operation on
    ///   errors it considers to be fatal.
    pub fn r#open_blob(
        &self,
        mut blob_id: &BlobId,
        mut allow_existing: bool,
    ) -> fidl::client::QueryResponseFut<
        NeededBlobsOpenBlobResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        NeededBlobsProxyInterface::r#open_blob(self, blob_id, allow_existing)
    }

    /// Indicates that a blob opened by `Open[Meta]Blob` has been successfully
    /// written.
    ///
    /// A client should call this once the blob has been fully written using
    /// the `writer` returned by `Open[Meta]Blob`.
    ///
    /// + request `blob_id` the blob id describing this blob.
    /// * error a BlobWrittenError indicating failure. Clients may retry the
    ///   `Open[Meta]Blob` request that prompted this call, though the server
    ///   end may abort this cache operation on errors it considers to be fatal.
    pub fn r#blob_written(
        &self,
        mut blob_id: &BlobId,
    ) -> fidl::client::QueryResponseFut<
        NeededBlobsBlobWrittenResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        NeededBlobsProxyInterface::r#blob_written(self, blob_id)
    }

    /// Aborts this caching operation for the package.
    ///
    /// Any open blobs and any missing blobs iterator will be closed. Any `dir`
    /// provided to the associated [`PackageCache.Get`] request will also be
    /// closed. Once this request is acknowledged, this channel will be closed.
    ///
    /// Note, dropping this NeededBlobs channel without writing all needed blobs
    /// will also abort the package cache operation. However, this API provides
    /// the ability to wait for the operation to be torn down.
    pub fn r#abort(
        &self,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        NeededBlobsProxyInterface::r#abort(self)
    }
}

impl NeededBlobsProxyInterface for NeededBlobsProxy {
    type OpenMetaBlobResponseFut = fidl::client::QueryResponseFut<
        NeededBlobsOpenMetaBlobResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#open_meta_blob(&self) -> Self::OpenMetaBlobResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NeededBlobsOpenMetaBlobResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<NeededBlobsOpenMetaBlobResponse, OpenBlobError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x42f385a58180f5fb,
            >(_buf?)?;
            Ok(_response.map(|x| x.writer))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, NeededBlobsOpenMetaBlobResult>(
                (),
                0x42f385a58180f5fb,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    fn r#get_missing_blobs(
        &self,
        mut iterator: fidl::endpoints::ServerEnd<BlobInfoIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<NeededBlobsGetMissingBlobsRequest>(
            (iterator,),
            0x44eaf14fd56e7ae1,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type OpenBlobResponseFut = fidl::client::QueryResponseFut<
        NeededBlobsOpenBlobResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#open_blob(
        &self,
        mut blob_id: &BlobId,
        mut allow_existing: bool,
    ) -> Self::OpenBlobResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NeededBlobsOpenBlobResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<NeededBlobsOpenBlobResponse, OpenBlobError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x67cd4c4cd10ea9e0,
            >(_buf?)?;
            Ok(_response.map(|x| x.writer))
        }
        self.client.send_query_and_decode::<NeededBlobsOpenBlobRequest, NeededBlobsOpenBlobResult>(
            (blob_id, allow_existing),
            0x67cd4c4cd10ea9e0,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type BlobWrittenResponseFut = fidl::client::QueryResponseFut<
        NeededBlobsBlobWrittenResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#blob_written(&self, mut blob_id: &BlobId) -> Self::BlobWrittenResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NeededBlobsBlobWrittenResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, BlobWrittenError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x222f80ec77433f44,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<NeededBlobsBlobWrittenRequest, NeededBlobsBlobWrittenResult>(
                (blob_id,),
                0x222f80ec77433f44,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for NeededBlobsRequestStream {
    type Protocol = NeededBlobsMarker;
    type ControlHandle = NeededBlobsControlHandle;

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x42f385a58180f5fb => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = NeededBlobsControlHandle { inner: this.inner.clone() };
                        Ok(NeededBlobsRequest::OpenMetaBlob {
                            responder: NeededBlobsOpenMetaBlobResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x44eaf14fd56e7ae1 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            NeededBlobsGetMissingBlobsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NeededBlobsGetMissingBlobsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = NeededBlobsControlHandle { inner: this.inner.clone() };
                        Ok(NeededBlobsRequest::GetMissingBlobs {
                            iterator: req.iterator,

                            control_handle,
                        })
                    }
                    0x67cd4c4cd10ea9e0 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NeededBlobsOpenBlobRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NeededBlobsOpenBlobRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = NeededBlobsControlHandle { inner: this.inner.clone() };
                        Ok(NeededBlobsRequest::OpenBlob {
                            blob_id: req.blob_id,
                            allow_existing: req.allow_existing,

                            responder: NeededBlobsOpenBlobResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x222f80ec77433f44 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NeededBlobsBlobWrittenRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NeededBlobsBlobWrittenRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = NeededBlobsControlHandle { inner: this.inner.clone() };
                        Ok(NeededBlobsRequest::BlobWritten {
                            blob_id: req.blob_id,

                            responder: NeededBlobsBlobWrittenResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6fda8d5ebea74cbb => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = NeededBlobsControlHandle { inner: this.inner.clone() };
                        Ok(NeededBlobsRequest::Abort {
                            responder: NeededBlobsAbortResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <NeededBlobsMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Represents the transaction for caching a particular package.
///
/// Server expects client to follow the normal operation sequence defined below.
/// Violating the protocol (e.g. calling wrong methods at the wrong time) will result
/// in the channel being closed by the package cache with a `ZX_ERR_BAD_STATE` epitaph
/// and aborting the package cache operation.
/// If a fatal error occurs at any step, server will close the channel, and client
/// should not proceed with the sequence.
/// Non-fatal errors could be retried, as long as the channel remains open.
///
/// Normal operation sequence:
/// 1. Clients should start by requesting to `OpenMetaBlob()`, and fetch and write
/// the metadata blob if needed, calling `BlobWritten()` when done to indicate the
/// write is complete.
/// 2. `GetMissingBlobs()` should be used to determine which blobs need to be
/// fetched and written.
/// 3. Each of the missing blobs needs to be written using `OpenBlob()` and
/// `BlobWritten()` should be called after each blob is written.
///
/// Clients are responsible for avoiding concurrent creation of the same blob if the underlying
/// blobstore does not support it. This currently manifests as the requirement that Clients close
/// the `BlobWriter` handle before retrying blob creation.
/// This applies per `BlobId` to all `BlobWriter`s returned by all calls to `Open[Meta]Blob` across
/// all `NeededBlobs` connections across all `PackageCache` connections.
///
/// Once all needed blobs are written by the client, the package cache will
/// complete the pending [`PackageCache.Get`] request and close this channel
/// with a `ZX_OK` epitaph.
#[derive(Debug)]
pub enum NeededBlobsRequest {
    /// Opens the package's metadata blob for writing. `GetMissingBlobs()`
    /// should not be called until writing the meta blob or this request
    /// responds with `false`.
    ///
    /// If the package was already cached, server will close the channel with a
    /// `ZX_OK` epitaph.
    ///
    /// - response `writer` is used to write the blob. If `writer` is absent,
    ///   the blob is already cached and so does not need to be written.
    /// * error an OpenBlobError indicating failure. Clients may retry this
    ///   request, though the server end may abort this cache operation on
    ///   errors it considers to be fatal.
    OpenMetaBlob { responder: NeededBlobsOpenMetaBlobResponder },
    /// Returns an iterator of blobs that are not present on the system that
    /// must be written using the `OpenBlob` request before the package will be
    /// fully cached.
    ///
    /// Client should call `OpenMetaBlob`, and write it if needed, before
    /// calling `GetMissingBlobs`.
    ///
    /// A client should make this request no more than once per `NeededBlobs`
    /// connection. Once all blobs yielded by this iterator are written, the
    /// package open request will complete.
    ///
    /// New items may be added to the obtained `BlobInfoIterator` as the client
    /// calls `OpenBlob`, so, to guaranatee termination of the iterator, clients
    /// should call `OpenBlob` concurrently with reading the iterator.
    ///
    /// + request `iterator` a request for an iterator of [`BlobInfo`] of blobs
    ///   that the client should try to write.
    GetMissingBlobs {
        iterator: fidl::endpoints::ServerEnd<BlobInfoIteratorMarker>,
        control_handle: NeededBlobsControlHandle,
    },
    /// Opens a blob for writing.
    ///
    /// + request `blob_id` the blob id describing this blob.
    /// + request `allow_existing` whether to open the blob even if it is already present.
    /// - response `writer` is used to write the blob. If `writer` is absent,
    ///   the blob is already cached and so does not need to be written.
    /// * error an OpenBlobError indicating failure. Clients may retry this
    ///   request, though the server end may abort this cache operation on
    ///   errors it considers to be fatal.
    OpenBlob { blob_id: BlobId, allow_existing: bool, responder: NeededBlobsOpenBlobResponder },
    /// Indicates that a blob opened by `Open[Meta]Blob` has been successfully
    /// written.
    ///
    /// A client should call this once the blob has been fully written using
    /// the `writer` returned by `Open[Meta]Blob`.
    ///
    /// + request `blob_id` the blob id describing this blob.
    /// * error a BlobWrittenError indicating failure. Clients may retry the
    ///   `Open[Meta]Blob` request that prompted this call, though the server
    ///   end may abort this cache operation on errors it considers to be fatal.
    BlobWritten { blob_id: BlobId, responder: NeededBlobsBlobWrittenResponder },
    /// Aborts this caching operation for the package.
    ///
    /// Any open blobs and any missing blobs iterator will be closed. Any `dir`
    /// provided to the associated [`PackageCache.Get`] request will also be
    /// closed. Once this request is acknowledged, this channel will be closed.
    ///
    /// Note, dropping this NeededBlobs channel without writing all needed blobs
    /// will also abort the package cache operation. However, this API provides
    /// the ability to wait for the operation to be torn down.
    Abort { responder: NeededBlobsAbortResponder },
}

impl NeededBlobsRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_open_meta_blob(self) -> Option<(NeededBlobsOpenMetaBlobResponder)> {
        if let NeededBlobsRequest::OpenMetaBlob { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_missing_blobs(
        self,
    ) -> Option<(fidl::endpoints::ServerEnd<BlobInfoIteratorMarker>, NeededBlobsControlHandle)>
    {
        if let NeededBlobsRequest::GetMissingBlobs { iterator, control_handle } = self {
            Some((iterator, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_open_blob(self) -> Option<(BlobId, bool, NeededBlobsOpenBlobResponder)> {
        if let NeededBlobsRequest::OpenBlob { blob_id, allow_existing, responder } = self {
            Some((blob_id, allow_existing, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_blob_written(self) -> Option<(BlobId, NeededBlobsBlobWrittenResponder)> {
        if let NeededBlobsRequest::BlobWritten { blob_id, responder } = self {
            Some((blob_id, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_abort(self) -> Option<(NeededBlobsAbortResponder)> {
        if let NeededBlobsRequest::Abort { responder } = self { Some((responder)) } else { None }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            NeededBlobsRequest::OpenMetaBlob { .. } => "open_meta_blob",
            NeededBlobsRequest::GetMissingBlobs { .. } => "get_missing_blobs",
            NeededBlobsRequest::OpenBlob { .. } => "open_blob",
            NeededBlobsRequest::BlobWritten { .. } => "blob_written",
            NeededBlobsRequest::Abort { .. } => "abort",
        }
    }
}

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

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

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

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        self.inner.shutdown_with_epitaph(status)
    }

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

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

impl NeededBlobsControlHandle {}

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

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

impl fidl::endpoints::Responder for NeededBlobsOpenMetaBlobResponder {
    type ControlHandle = NeededBlobsControlHandle;

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

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

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

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

impl fidl::endpoints::Responder for NeededBlobsOpenBlobResponder {
    type ControlHandle = NeededBlobsControlHandle;

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

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

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

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

impl fidl::endpoints::Responder for NeededBlobsBlobWrittenResponder {
    type ControlHandle = NeededBlobsControlHandle;

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

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

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

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

impl fidl::endpoints::Responder for NeededBlobsAbortResponder {
    type ControlHandle = NeededBlobsControlHandle;

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

    fn send_raw(&self) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
            (),
            self.tx_id,
            0x6fda8d5ebea74cbb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for PackageCacheMarker {
    type Proxy = PackageCacheProxy;
    type RequestStream = PackageCacheRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = PackageCacheSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.pkg.PackageCache";
}
impl fidl::endpoints::DiscoverableProtocolMarker for PackageCacheMarker {}
pub type PackageCacheGetResult = Result<(), i32>;
pub type PackageCacheGetSubpackageResult = Result<(), GetSubpackageError>;
pub type PackageCacheSyncResult = Result<(), i32>;
pub type PackageCacheSetUpgradableUrlsResult = Result<(), SetUpgradableUrlsError>;

pub trait PackageCacheProxyInterface: Send + Sync {
    type GetResponseFut: std::future::Future<Output = Result<PackageCacheGetResult, fidl::Error>>
        + Send;
    fn r#get(
        &self,
        meta_far_blob: &BlobInfo,
        gc_protection: GcProtection,
        needed_blobs: fidl::endpoints::ServerEnd<NeededBlobsMarker>,
        dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
    ) -> Self::GetResponseFut;
    fn r#write_blobs(
        &self,
        needed_blobs: fidl::endpoints::ServerEnd<NeededBlobsMarker>,
    ) -> Result<(), fidl::Error>;
    type GetSubpackageResponseFut: std::future::Future<Output = Result<PackageCacheGetSubpackageResult, fidl::Error>>
        + Send;
    fn r#get_subpackage(
        &self,
        superpackage: &BlobId,
        subpackage: &PackageUrl,
        dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
    ) -> Self::GetSubpackageResponseFut;
    fn r#base_package_index(
        &self,
        iterator: fidl::endpoints::ServerEnd<PackageIndexIteratorMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#cache_package_index(
        &self,
        iterator: fidl::endpoints::ServerEnd<PackageIndexIteratorMarker>,
    ) -> Result<(), fidl::Error>;
    type SyncResponseFut: std::future::Future<Output = Result<PackageCacheSyncResult, fidl::Error>>
        + Send;
    fn r#sync(&self) -> Self::SyncResponseFut;
    type SetUpgradableUrlsResponseFut: std::future::Future<Output = Result<PackageCacheSetUpgradableUrlsResult, fidl::Error>>
        + Send;
    fn r#set_upgradable_urls(
        &self,
        pinned_urls: &[PackageUrl],
    ) -> Self::SetUpgradableUrlsResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct PackageCacheSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for PackageCacheSynchronousProxy {
    type Proxy = PackageCacheProxy;
    type Protocol = PackageCacheMarker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl PackageCacheSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

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

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

    /// Gets the package directory if it is present on the local system. If it is not, the
    /// `missing_blobs` iterator will provide all the blobs in the package that are missing from
    /// the system, and the ability to write those blobs to blobfs. If all the missing blobs are
    /// downloaded and written to by the client, the `dir` directory will be resolved. This method
    /// will return successfully when the package has been fully resolved, or return an error if
    /// the client closes `needed_blobs` or `dir` handle before the package has been resolved.
    ///
    /// This method does not guarantee the missing blobs have been persisted. In order to guarantee
    /// missing blobs are persisted, clients should call ['Sync'].
    ///
    /// Clients must not make concurrent `Get()` calls for the same `meta_far_blob`, even across
    /// different `PackageCache` connections, *unless* the `meta_far_blob` is in base or already
    /// active in the dynamic index. Violating this may result in `Get()` errors.
    ///
    /// + request `meta_far_blob` the blob info for the package's meta.far.
    /// + request `needed_blobs` an iterator over all the blobs in the package that
    ///   are not present on the system.
    /// + request `dir` the channel on which the package directory will be served.
    /// * error a zx_status value indicating failure. One of the following:
    ///     * `ZX_ERR_UNAVAILABLE` if the client closed `needed_blobs` handles before
    ///       all the missing blobs were downloaded to the system.
    pub fn r#get(
        &self,
        mut meta_far_blob: &BlobInfo,
        mut gc_protection: GcProtection,
        mut needed_blobs: fidl::endpoints::ServerEnd<NeededBlobsMarker>,
        mut dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<PackageCacheGetResult, fidl::Error> {
        let _response = self.client.send_query::<
            PackageCacheGetRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            PackageCacheMarker,
        >(
            (meta_far_blob, gc_protection, needed_blobs, dir,),
            0x15e1963f4bf123b5,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Writes blobs to the system.
    ///
    /// This method is intended to be used by package resolver components to write individual blobs
    /// that are missing from the system.
    ///
    /// Clients must avoid write collisions of any blobs with `Get()` or another `WriteBlobs()`,
    /// even across different `PackageCache` connections.
    ///
    /// + request `needed_blobs` a protocol can be used to write multiple blobs. This `NeededBlobs`
    ///   only supports `OpenBlob` and `BlobWritten`.
    pub fn r#write_blobs(
        &self,
        mut needed_blobs: fidl::endpoints::ServerEnd<NeededBlobsMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PackageCacheWriteBlobsRequest>(
            (needed_blobs,),
            0x5d0ed48035931dbe,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Gets the package directory for a subpackage.
    /// The connection to the superpackage's package directory must still be open when this is
    /// called.
    /// The returned package will be protected by open package tracking.
    ///
    /// + request `superpackage` the hash of the superpackage's meta.far.
    /// + request `subpackage` the relative package URL of the subpackage.
    /// + request `dir` the channel on which the package directory will be served.
    /// * error a GetSubpackageError value indicating failure.
    pub fn r#get_subpackage(
        &self,
        mut superpackage: &BlobId,
        mut subpackage: &PackageUrl,
        mut dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<PackageCacheGetSubpackageResult, fidl::Error> {
        let _response =
            self.client.send_query::<PackageCacheGetSubpackageRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                GetSubpackageError,
            >, PackageCacheMarker>(
                (superpackage, subpackage, dir),
                0x29478df87c29ffa3,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Retrieves a chunk iterator to the base package index.
    ///
    /// + request `iterator` a request for the `PackageIndexIterator` that will return sets of
    ///   `PackageIndexEntry` objects until all packages in the base index have been iterated.
    pub fn r#base_package_index(
        &self,
        mut iterator: fidl::endpoints::ServerEnd<PackageIndexIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PackageCacheBasePackageIndexRequest>(
            (iterator,),
            0x46af9e595f8eced4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Retrieves a chunk iterator to the cache package index.
    ///
    /// + request `iterator` a request for the `PackageIndexIterator` that will return sets of
    ///   `PackageIndexEntry` objects until all packages in the cache index have been iterated.
    pub fn r#cache_package_index(
        &self,
        mut iterator: fidl::endpoints::ServerEnd<PackageIndexIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PackageCacheCachePackageIndexRequest>(
            (iterator,),
            0x14a48fdb8f26ed26,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Synchronizes updates to the cached packages to the underlying persistent storage.
    ///
    /// * error a zx_status value indicating failure. One of the following:
    ///     * `ZX_ERR_INTERNAL` if the sync fails.
    pub fn r#sync(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<PackageCacheSyncResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            PackageCacheMarker,
        >(
            (),
            0x5c10a84094535a74,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Sets which package URLs correspond to upgradable packages and the hash they should resolve
    /// to.
    ///
    /// If upgradable packages are enabled in pkg-cache, this method must be called once on start up
    /// to set the hashes for persisted upgradable packages. All such packages must not be base
    /// packages. If none of the upgradable packages are persisted, a call with an empty vector
    /// still needs to be made. Package resolution of non base packages and GC (and therefore OTA)
    /// will block until this is done.
    ///
    /// Subsequent calls can be made to set new upgradable packages or change the hashes associated
    /// with upgradable packages.
    ///
    /// The hash most recently associated with an upgradable package URL will be protected from GC.
    ///
    /// + request `pinned_urls` packages URLs pinned to the new hash.
    pub fn r#set_upgradable_urls(
        &self,
        mut pinned_urls: &[PackageUrl],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<PackageCacheSetUpgradableUrlsResult, fidl::Error> {
        let _response = self.client.send_query::<
            PackageCacheSetUpgradableUrlsRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, SetUpgradableUrlsError>,
            PackageCacheMarker,
        >(
            (pinned_urls,),
            0x2c235f7efdb5e2d1,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<PackageCacheMarker>("set_upgradable_urls")?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for PackageCacheProxy {
    type Protocol = PackageCacheMarker;

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

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

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

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

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

    /// Gets the package directory if it is present on the local system. If it is not, the
    /// `missing_blobs` iterator will provide all the blobs in the package that are missing from
    /// the system, and the ability to write those blobs to blobfs. If all the missing blobs are
    /// downloaded and written to by the client, the `dir` directory will be resolved. This method
    /// will return successfully when the package has been fully resolved, or return an error if
    /// the client closes `needed_blobs` or `dir` handle before the package has been resolved.
    ///
    /// This method does not guarantee the missing blobs have been persisted. In order to guarantee
    /// missing blobs are persisted, clients should call ['Sync'].
    ///
    /// Clients must not make concurrent `Get()` calls for the same `meta_far_blob`, even across
    /// different `PackageCache` connections, *unless* the `meta_far_blob` is in base or already
    /// active in the dynamic index. Violating this may result in `Get()` errors.
    ///
    /// + request `meta_far_blob` the blob info for the package's meta.far.
    /// + request `needed_blobs` an iterator over all the blobs in the package that
    ///   are not present on the system.
    /// + request `dir` the channel on which the package directory will be served.
    /// * error a zx_status value indicating failure. One of the following:
    ///     * `ZX_ERR_UNAVAILABLE` if the client closed `needed_blobs` handles before
    ///       all the missing blobs were downloaded to the system.
    pub fn r#get(
        &self,
        mut meta_far_blob: &BlobInfo,
        mut gc_protection: GcProtection,
        mut needed_blobs: fidl::endpoints::ServerEnd<NeededBlobsMarker>,
        mut dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
    ) -> fidl::client::QueryResponseFut<
        PackageCacheGetResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        PackageCacheProxyInterface::r#get(self, meta_far_blob, gc_protection, needed_blobs, dir)
    }

    /// Writes blobs to the system.
    ///
    /// This method is intended to be used by package resolver components to write individual blobs
    /// that are missing from the system.
    ///
    /// Clients must avoid write collisions of any blobs with `Get()` or another `WriteBlobs()`,
    /// even across different `PackageCache` connections.
    ///
    /// + request `needed_blobs` a protocol can be used to write multiple blobs. This `NeededBlobs`
    ///   only supports `OpenBlob` and `BlobWritten`.
    pub fn r#write_blobs(
        &self,
        mut needed_blobs: fidl::endpoints::ServerEnd<NeededBlobsMarker>,
    ) -> Result<(), fidl::Error> {
        PackageCacheProxyInterface::r#write_blobs(self, needed_blobs)
    }

    /// Gets the package directory for a subpackage.
    /// The connection to the superpackage's package directory must still be open when this is
    /// called.
    /// The returned package will be protected by open package tracking.
    ///
    /// + request `superpackage` the hash of the superpackage's meta.far.
    /// + request `subpackage` the relative package URL of the subpackage.
    /// + request `dir` the channel on which the package directory will be served.
    /// * error a GetSubpackageError value indicating failure.
    pub fn r#get_subpackage(
        &self,
        mut superpackage: &BlobId,
        mut subpackage: &PackageUrl,
        mut dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
    ) -> fidl::client::QueryResponseFut<
        PackageCacheGetSubpackageResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        PackageCacheProxyInterface::r#get_subpackage(self, superpackage, subpackage, dir)
    }

    /// Retrieves a chunk iterator to the base package index.
    ///
    /// + request `iterator` a request for the `PackageIndexIterator` that will return sets of
    ///   `PackageIndexEntry` objects until all packages in the base index have been iterated.
    pub fn r#base_package_index(
        &self,
        mut iterator: fidl::endpoints::ServerEnd<PackageIndexIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        PackageCacheProxyInterface::r#base_package_index(self, iterator)
    }

    /// Retrieves a chunk iterator to the cache package index.
    ///
    /// + request `iterator` a request for the `PackageIndexIterator` that will return sets of
    ///   `PackageIndexEntry` objects until all packages in the cache index have been iterated.
    pub fn r#cache_package_index(
        &self,
        mut iterator: fidl::endpoints::ServerEnd<PackageIndexIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        PackageCacheProxyInterface::r#cache_package_index(self, iterator)
    }

    /// Synchronizes updates to the cached packages to the underlying persistent storage.
    ///
    /// * error a zx_status value indicating failure. One of the following:
    ///     * `ZX_ERR_INTERNAL` if the sync fails.
    pub fn r#sync(
        &self,
    ) -> fidl::client::QueryResponseFut<
        PackageCacheSyncResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        PackageCacheProxyInterface::r#sync(self)
    }

    /// Sets which package URLs correspond to upgradable packages and the hash they should resolve
    /// to.
    ///
    /// If upgradable packages are enabled in pkg-cache, this method must be called once on start up
    /// to set the hashes for persisted upgradable packages. All such packages must not be base
    /// packages. If none of the upgradable packages are persisted, a call with an empty vector
    /// still needs to be made. Package resolution of non base packages and GC (and therefore OTA)
    /// will block until this is done.
    ///
    /// Subsequent calls can be made to set new upgradable packages or change the hashes associated
    /// with upgradable packages.
    ///
    /// The hash most recently associated with an upgradable package URL will be protected from GC.
    ///
    /// + request `pinned_urls` packages URLs pinned to the new hash.
    pub fn r#set_upgradable_urls(
        &self,
        mut pinned_urls: &[PackageUrl],
    ) -> fidl::client::QueryResponseFut<
        PackageCacheSetUpgradableUrlsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        PackageCacheProxyInterface::r#set_upgradable_urls(self, pinned_urls)
    }
}

impl PackageCacheProxyInterface for PackageCacheProxy {
    type GetResponseFut = fidl::client::QueryResponseFut<
        PackageCacheGetResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get(
        &self,
        mut meta_far_blob: &BlobInfo,
        mut gc_protection: GcProtection,
        mut needed_blobs: fidl::endpoints::ServerEnd<NeededBlobsMarker>,
        mut dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
    ) -> Self::GetResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<PackageCacheGetResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x15e1963f4bf123b5,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<PackageCacheGetRequest, PackageCacheGetResult>(
            (meta_far_blob, gc_protection, needed_blobs, dir),
            0x15e1963f4bf123b5,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#write_blobs(
        &self,
        mut needed_blobs: fidl::endpoints::ServerEnd<NeededBlobsMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PackageCacheWriteBlobsRequest>(
            (needed_blobs,),
            0x5d0ed48035931dbe,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type GetSubpackageResponseFut = fidl::client::QueryResponseFut<
        PackageCacheGetSubpackageResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_subpackage(
        &self,
        mut superpackage: &BlobId,
        mut subpackage: &PackageUrl,
        mut dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
    ) -> Self::GetSubpackageResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<PackageCacheGetSubpackageResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, GetSubpackageError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x29478df87c29ffa3,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            PackageCacheGetSubpackageRequest,
            PackageCacheGetSubpackageResult,
        >(
            (superpackage, subpackage, dir,),
            0x29478df87c29ffa3,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#base_package_index(
        &self,
        mut iterator: fidl::endpoints::ServerEnd<PackageIndexIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PackageCacheBasePackageIndexRequest>(
            (iterator,),
            0x46af9e595f8eced4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#cache_package_index(
        &self,
        mut iterator: fidl::endpoints::ServerEnd<PackageIndexIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PackageCacheCachePackageIndexRequest>(
            (iterator,),
            0x14a48fdb8f26ed26,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

    type SetUpgradableUrlsResponseFut = fidl::client::QueryResponseFut<
        PackageCacheSetUpgradableUrlsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_upgradable_urls(
        &self,
        mut pinned_urls: &[PackageUrl],
    ) -> Self::SetUpgradableUrlsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<PackageCacheSetUpgradableUrlsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<
                    fidl::encoding::EmptyStruct,
                    SetUpgradableUrlsError,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2c235f7efdb5e2d1,
            >(_buf?)?
            .into_result::<PackageCacheMarker>("set_upgradable_urls")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            PackageCacheSetUpgradableUrlsRequest,
            PackageCacheSetUpgradableUrlsResult,
        >(
            (pinned_urls,),
            0x2c235f7efdb5e2d1,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for PackageCacheRequestStream {
    type Protocol = PackageCacheMarker;
    type ControlHandle = PackageCacheControlHandle;

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x15e1963f4bf123b5 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            PackageCacheGetRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PackageCacheGetRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            PackageCacheControlHandle { inner: this.inner.clone() };
                        Ok(PackageCacheRequest::Get {
                            meta_far_blob: req.meta_far_blob,
                            gc_protection: req.gc_protection,
                            needed_blobs: req.needed_blobs,
                            dir: req.dir,

                            responder: PackageCacheGetResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5d0ed48035931dbe => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PackageCacheWriteBlobsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PackageCacheWriteBlobsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            PackageCacheControlHandle { inner: this.inner.clone() };
                        Ok(PackageCacheRequest::WriteBlobs {
                            needed_blobs: req.needed_blobs,

                            control_handle,
                        })
                    }
                    0x29478df87c29ffa3 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            PackageCacheGetSubpackageRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PackageCacheGetSubpackageRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            PackageCacheControlHandle { inner: this.inner.clone() };
                        Ok(PackageCacheRequest::GetSubpackage {
                            superpackage: req.superpackage,
                            subpackage: req.subpackage,
                            dir: req.dir,

                            responder: PackageCacheGetSubpackageResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x46af9e595f8eced4 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PackageCacheBasePackageIndexRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PackageCacheBasePackageIndexRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            PackageCacheControlHandle { inner: this.inner.clone() };
                        Ok(PackageCacheRequest::BasePackageIndex {
                            iterator: req.iterator,

                            control_handle,
                        })
                    }
                    0x14a48fdb8f26ed26 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PackageCacheCachePackageIndexRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PackageCacheCachePackageIndexRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            PackageCacheControlHandle { inner: this.inner.clone() };
                        Ok(PackageCacheRequest::CachePackageIndex {
                            iterator: req.iterator,

                            control_handle,
                        })
                    }
                    0x5c10a84094535a74 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            PackageCacheControlHandle { inner: this.inner.clone() };
                        Ok(PackageCacheRequest::Sync {
                            responder: PackageCacheSyncResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2c235f7efdb5e2d1 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            PackageCacheSetUpgradableUrlsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PackageCacheSetUpgradableUrlsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            PackageCacheControlHandle { inner: this.inner.clone() };
                        Ok(PackageCacheRequest::SetUpgradableUrls {
                            pinned_urls: req.pinned_urls,

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

/// This manages the system package cache.
///
/// This is intended to be implemented by the package manager component and used by
/// package resolver components.
#[derive(Debug)]
pub enum PackageCacheRequest {
    /// Gets the package directory if it is present on the local system. If it is not, the
    /// `missing_blobs` iterator will provide all the blobs in the package that are missing from
    /// the system, and the ability to write those blobs to blobfs. If all the missing blobs are
    /// downloaded and written to by the client, the `dir` directory will be resolved. This method
    /// will return successfully when the package has been fully resolved, or return an error if
    /// the client closes `needed_blobs` or `dir` handle before the package has been resolved.
    ///
    /// This method does not guarantee the missing blobs have been persisted. In order to guarantee
    /// missing blobs are persisted, clients should call ['Sync'].
    ///
    /// Clients must not make concurrent `Get()` calls for the same `meta_far_blob`, even across
    /// different `PackageCache` connections, *unless* the `meta_far_blob` is in base or already
    /// active in the dynamic index. Violating this may result in `Get()` errors.
    ///
    /// + request `meta_far_blob` the blob info for the package's meta.far.
    /// + request `needed_blobs` an iterator over all the blobs in the package that
    ///   are not present on the system.
    /// + request `dir` the channel on which the package directory will be served.
    /// * error a zx_status value indicating failure. One of the following:
    ///     * `ZX_ERR_UNAVAILABLE` if the client closed `needed_blobs` handles before
    ///       all the missing blobs were downloaded to the system.
    Get {
        meta_far_blob: BlobInfo,
        gc_protection: GcProtection,
        needed_blobs: fidl::endpoints::ServerEnd<NeededBlobsMarker>,
        dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
        responder: PackageCacheGetResponder,
    },
    /// Writes blobs to the system.
    ///
    /// This method is intended to be used by package resolver components to write individual blobs
    /// that are missing from the system.
    ///
    /// Clients must avoid write collisions of any blobs with `Get()` or another `WriteBlobs()`,
    /// even across different `PackageCache` connections.
    ///
    /// + request `needed_blobs` a protocol can be used to write multiple blobs. This `NeededBlobs`
    ///   only supports `OpenBlob` and `BlobWritten`.
    WriteBlobs {
        needed_blobs: fidl::endpoints::ServerEnd<NeededBlobsMarker>,
        control_handle: PackageCacheControlHandle,
    },
    /// Gets the package directory for a subpackage.
    /// The connection to the superpackage's package directory must still be open when this is
    /// called.
    /// The returned package will be protected by open package tracking.
    ///
    /// + request `superpackage` the hash of the superpackage's meta.far.
    /// + request `subpackage` the relative package URL of the subpackage.
    /// + request `dir` the channel on which the package directory will be served.
    /// * error a GetSubpackageError value indicating failure.
    GetSubpackage {
        superpackage: BlobId,
        subpackage: PackageUrl,
        dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
        responder: PackageCacheGetSubpackageResponder,
    },
    /// Retrieves a chunk iterator to the base package index.
    ///
    /// + request `iterator` a request for the `PackageIndexIterator` that will return sets of
    ///   `PackageIndexEntry` objects until all packages in the base index have been iterated.
    BasePackageIndex {
        iterator: fidl::endpoints::ServerEnd<PackageIndexIteratorMarker>,
        control_handle: PackageCacheControlHandle,
    },
    /// Retrieves a chunk iterator to the cache package index.
    ///
    /// + request `iterator` a request for the `PackageIndexIterator` that will return sets of
    ///   `PackageIndexEntry` objects until all packages in the cache index have been iterated.
    CachePackageIndex {
        iterator: fidl::endpoints::ServerEnd<PackageIndexIteratorMarker>,
        control_handle: PackageCacheControlHandle,
    },
    /// Synchronizes updates to the cached packages to the underlying persistent storage.
    ///
    /// * error a zx_status value indicating failure. One of the following:
    ///     * `ZX_ERR_INTERNAL` if the sync fails.
    Sync { responder: PackageCacheSyncResponder },
    /// Sets which package URLs correspond to upgradable packages and the hash they should resolve
    /// to.
    ///
    /// If upgradable packages are enabled in pkg-cache, this method must be called once on start up
    /// to set the hashes for persisted upgradable packages. All such packages must not be base
    /// packages. If none of the upgradable packages are persisted, a call with an empty vector
    /// still needs to be made. Package resolution of non base packages and GC (and therefore OTA)
    /// will block until this is done.
    ///
    /// Subsequent calls can be made to set new upgradable packages or change the hashes associated
    /// with upgradable packages.
    ///
    /// The hash most recently associated with an upgradable package URL will be protected from GC.
    ///
    /// + request `pinned_urls` packages URLs pinned to the new hash.
    SetUpgradableUrls {
        pinned_urls: Vec<PackageUrl>,
        responder: PackageCacheSetUpgradableUrlsResponder,
    },
    /// An interaction was received which does not match any known method.
    #[non_exhaustive]
    _UnknownMethod {
        /// Ordinal of the method that was called.
        ordinal: u64,
        control_handle: PackageCacheControlHandle,
        method_type: fidl::MethodType,
    },
}

impl PackageCacheRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get(
        self,
    ) -> Option<(
        BlobInfo,
        GcProtection,
        fidl::endpoints::ServerEnd<NeededBlobsMarker>,
        fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
        PackageCacheGetResponder,
    )> {
        if let PackageCacheRequest::Get {
            meta_far_blob,
            gc_protection,
            needed_blobs,
            dir,
            responder,
        } = self
        {
            Some((meta_far_blob, gc_protection, needed_blobs, dir, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_write_blobs(
        self,
    ) -> Option<(fidl::endpoints::ServerEnd<NeededBlobsMarker>, PackageCacheControlHandle)> {
        if let PackageCacheRequest::WriteBlobs { needed_blobs, control_handle } = self {
            Some((needed_blobs, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_subpackage(
        self,
    ) -> Option<(
        BlobId,
        PackageUrl,
        fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
        PackageCacheGetSubpackageResponder,
    )> {
        if let PackageCacheRequest::GetSubpackage { superpackage, subpackage, dir, responder } =
            self
        {
            Some((superpackage, subpackage, dir, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_base_package_index(
        self,
    ) -> Option<(fidl::endpoints::ServerEnd<PackageIndexIteratorMarker>, PackageCacheControlHandle)>
    {
        if let PackageCacheRequest::BasePackageIndex { iterator, control_handle } = self {
            Some((iterator, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_cache_package_index(
        self,
    ) -> Option<(fidl::endpoints::ServerEnd<PackageIndexIteratorMarker>, PackageCacheControlHandle)>
    {
        if let PackageCacheRequest::CachePackageIndex { iterator, control_handle } = self {
            Some((iterator, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_sync(self) -> Option<(PackageCacheSyncResponder)> {
        if let PackageCacheRequest::Sync { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_upgradable_urls(
        self,
    ) -> Option<(Vec<PackageUrl>, PackageCacheSetUpgradableUrlsResponder)> {
        if let PackageCacheRequest::SetUpgradableUrls { pinned_urls, responder } = self {
            Some((pinned_urls, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            PackageCacheRequest::Get { .. } => "get",
            PackageCacheRequest::WriteBlobs { .. } => "write_blobs",
            PackageCacheRequest::GetSubpackage { .. } => "get_subpackage",
            PackageCacheRequest::BasePackageIndex { .. } => "base_package_index",
            PackageCacheRequest::CachePackageIndex { .. } => "cache_package_index",
            PackageCacheRequest::Sync { .. } => "sync",
            PackageCacheRequest::SetUpgradableUrls { .. } => "set_upgradable_urls",
            PackageCacheRequest::_UnknownMethod {
                method_type: fidl::MethodType::OneWay, ..
            } => "unknown one-way method",
            PackageCacheRequest::_UnknownMethod {
                method_type: fidl::MethodType::TwoWay, ..
            } => "unknown two-way method",
        }
    }
}

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

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

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

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        self.inner.shutdown_with_epitaph(status)
    }

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

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

impl PackageCacheControlHandle {}

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

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

impl fidl::endpoints::Responder for PackageCacheGetResponder {
    type ControlHandle = PackageCacheControlHandle;

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

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

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

impl fidl::endpoints::Responder for PackageCacheGetSubpackageResponder {
    type ControlHandle = PackageCacheControlHandle;

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

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

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

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

impl fidl::endpoints::Responder for PackageCacheSyncResponder {
    type ControlHandle = PackageCacheControlHandle;

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

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

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

impl fidl::endpoints::Responder for PackageCacheSetUpgradableUrlsResponder {
    type ControlHandle = PackageCacheControlHandle;

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

    fn send_raw(&self, mut result: Result<(), SetUpgradableUrlsError>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
            fidl::encoding::EmptyStruct,
            SetUpgradableUrlsError,
        >>(
            fidl::encoding::FlexibleResult::new(result),
            self.tx_id,
            0x2c235f7efdb5e2d1,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for PackageIndexIteratorMarker {
    type Proxy = PackageIndexIteratorProxy;
    type RequestStream = PackageIndexIteratorRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = PackageIndexIteratorSynchronousProxy;

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

pub trait PackageIndexIteratorProxyInterface: Send + Sync {
    type NextResponseFut: std::future::Future<Output = Result<Vec<PackageIndexEntry>, fidl::Error>>
        + Send;
    fn r#next(&self) -> Self::NextResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct PackageIndexIteratorSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for PackageIndexIteratorSynchronousProxy {
    type Proxy = PackageIndexIteratorProxy;
    type Protocol = PackageIndexIteratorMarker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl PackageIndexIteratorSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

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

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

    /// Returns the next chunk of package index entries. When the iterator is exhausted,
    /// this returns an empty vector.
    ///
    /// - response `entries` the next chunk of entries in the package index.
    pub fn r#next(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Vec<PackageIndexEntry>, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            PackageIndexIteratorNextResponse,
            PackageIndexIteratorMarker,
        >(
            (),
            0x9de6bbc87c314d9,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.entries)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for PackageIndexIteratorProxy {
    type Protocol = PackageIndexIteratorMarker;

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

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

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

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

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

    /// Returns the next chunk of package index entries. When the iterator is exhausted,
    /// this returns an empty vector.
    ///
    /// - response `entries` the next chunk of entries in the package index.
    pub fn r#next(
        &self,
    ) -> fidl::client::QueryResponseFut<
        Vec<PackageIndexEntry>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        PackageIndexIteratorProxyInterface::r#next(self)
    }
}

impl PackageIndexIteratorProxyInterface for PackageIndexIteratorProxy {
    type NextResponseFut = fidl::client::QueryResponseFut<
        Vec<PackageIndexEntry>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#next(&self) -> Self::NextResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<PackageIndexEntry>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                PackageIndexIteratorNextResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x9de6bbc87c314d9,
            >(_buf?)?;
            Ok(_response.entries)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<PackageIndexEntry>>(
            (),
            0x9de6bbc87c314d9,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for PackageIndexIteratorRequestStream {
    type Protocol = PackageIndexIteratorMarker;
    type ControlHandle = PackageIndexIteratorControlHandle;

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                0x9de6bbc87c314d9 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = PackageIndexIteratorControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(PackageIndexIteratorRequest::Next {
                        responder: PackageIndexIteratorNextResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <PackageIndexIteratorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// A chunk iterator for the package index. This is required because it is possible for the
/// package index to be too large to send over in a single request (over 64KiB).
#[derive(Debug)]
pub enum PackageIndexIteratorRequest {
    /// Returns the next chunk of package index entries. When the iterator is exhausted,
    /// this returns an empty vector.
    ///
    /// - response `entries` the next chunk of entries in the package index.
    Next { responder: PackageIndexIteratorNextResponder },
}

impl PackageIndexIteratorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_next(self) -> Option<(PackageIndexIteratorNextResponder)> {
        if let PackageIndexIteratorRequest::Next { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

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

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

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

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

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        self.inner.shutdown_with_epitaph(status)
    }

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

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

impl PackageIndexIteratorControlHandle {}

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

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

impl fidl::endpoints::Responder for PackageIndexIteratorNextResponder {
    type ControlHandle = PackageIndexIteratorControlHandle;

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

    fn send_raw(&self, mut entries: &[PackageIndexEntry]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<PackageIndexIteratorNextResponse>(
            (entries,),
            self.tx_id,
            0x9de6bbc87c314d9,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for PackageResolverMarker {
    type Proxy = PackageResolverProxy;
    type RequestStream = PackageResolverRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = PackageResolverSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.pkg.PackageResolver";
}
impl fidl::endpoints::DiscoverableProtocolMarker for PackageResolverMarker {}
pub type PackageResolverResolveResult = Result<ResolutionContext, ResolveError>;
pub type PackageResolverResolveWithContextResult = Result<ResolutionContext, ResolveError>;
pub type PackageResolverGetHashResult = Result<BlobId, i32>;

pub trait PackageResolverProxyInterface: Send + Sync {
    type ResolveResponseFut: std::future::Future<Output = Result<PackageResolverResolveResult, fidl::Error>>
        + Send;
    fn r#resolve(
        &self,
        package_url: &str,
        dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
    ) -> Self::ResolveResponseFut;
    type ResolveWithContextResponseFut: std::future::Future<Output = Result<PackageResolverResolveWithContextResult, fidl::Error>>
        + Send;
    fn r#resolve_with_context(
        &self,
        package_url: &str,
        context: &ResolutionContext,
        dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
    ) -> Self::ResolveWithContextResponseFut;
    type GetHashResponseFut: std::future::Future<Output = Result<PackageResolverGetHashResult, fidl::Error>>
        + Send;
    fn r#get_hash(&self, package_url: &PackageUrl) -> Self::GetHashResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct PackageResolverSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for PackageResolverSynchronousProxy {
    type Proxy = PackageResolverProxy;
    type Protocol = PackageResolverMarker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl PackageResolverSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

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

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

    /// Populates or updates the cache of a package using an absolute package
    /// URL.
    ///
    /// Ensures that a package, and any transitive subpackages, are on the local
    /// filesystem.
    ///
    /// + request `package_url` the absolute package URL for a package.  The
    ///   following link describes the format:
    ///   https://fuchsia.dev/fuchsia-src/concepts/packages/package_url.
    ///   Resource paths are not allowed.
    /// + request `dir` a request for a directory that will be resolved when the
    ///   package has been successfully cached.
    /// + returns a `resolved_context`, which can be passed to
    ///   `ResolveWithContext`, with a relative URL, to resolve a subpackage of
    ///   this package.
    /// * error indicates failure. See `ResolveError` for values and error
    ///   scenarios.
    pub fn r#resolve(
        &self,
        mut package_url: &str,
        mut dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<PackageResolverResolveResult, fidl::Error> {
        let _response = self.client.send_query::<
            PackageResolverResolveRequest,
            fidl::encoding::ResultType<PackageResolverResolveResponse, ResolveError>,
            PackageResolverMarker,
        >(
            (package_url, dir,),
            0x6611263be4052d4f,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.resolved_context))
    }

    /// Populates or updates the cache of a package using either an absolute or
    /// a relative package URL. If relative, the package will be resolved
    /// relative to the supplied `context`.
    ///
    /// Ensures that a package is on the local filesystem.
    ///
    /// + request `package_url` the absolute or relative package URL for a
    ///   package. If absolute, the `context` is ignored, and the behavior is
    ///   identical to calling `Resolve()`. A relative `package_url` is a
    ///   subpackage name.
    /// + request `context` a `ResolutionContext` associated with a previously
    ///   resolved package, for resolving subpackages relative to that package.
    /// + request `dir` a request for a directory that will be resolved when the
    ///   package has been successfully cached.
    /// + returns a `resolved_context`, which can be passed to a subsequent call
    ///   to `ResolveWithContext`, with a relative URL, to resolve a subpackage
    ///   of this package or subpackage.
    /// * error indicates failure. See `ResolveError` for values and error
    ///   scenarios.
    pub fn r#resolve_with_context(
        &self,
        mut package_url: &str,
        mut context: &ResolutionContext,
        mut dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<PackageResolverResolveWithContextResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<PackageResolverResolveWithContextRequest, fidl::encoding::ResultType<
                    PackageResolverResolveWithContextResponse,
                    ResolveError,
                >, PackageResolverMarker>(
                    (package_url, context, dir),
                    0x4c255ae7260298d4,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x.resolved_context))
    }

    /// Determines the hash of a package.
    ///
    /// + request `package_url` the package URL for a package.
    /// - response `meta_far_blob_id` the hash of the package.
    /// * error a zx_status value indicating failure. One of the following:
    ///     * `ZX_ERR_INTERNAL` if the resolver encountered an otherwise unspecified error
    ///       while handling the request.
    ///     * `ZX_ERR_NOT_FOUND` if the package does not exist in the repository specified by
    ///       `package_url`.
    ///     * `ZX_ERR_BAD_STATE` if the resolver does not know about the repository specified by
    ///       `package_url`.
    pub fn r#get_hash(
        &self,
        mut package_url: &PackageUrl,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<PackageResolverGetHashResult, fidl::Error> {
        let _response = self.client.send_query::<
            PackageResolverGetHashRequest,
            fidl::encoding::ResultType<PackageResolverGetHashResponse, i32>,
            PackageResolverMarker,
        >(
            (package_url,),
            0x594e8b4db51efd87,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.meta_far_blob_id))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for PackageResolverProxy {
    type Protocol = PackageResolverMarker;

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

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

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

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

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

    /// Populates or updates the cache of a package using an absolute package
    /// URL.
    ///
    /// Ensures that a package, and any transitive subpackages, are on the local
    /// filesystem.
    ///
    /// + request `package_url` the absolute package URL for a package.  The
    ///   following link describes the format:
    ///   https://fuchsia.dev/fuchsia-src/concepts/packages/package_url.
    ///   Resource paths are not allowed.
    /// + request `dir` a request for a directory that will be resolved when the
    ///   package has been successfully cached.
    /// + returns a `resolved_context`, which can be passed to
    ///   `ResolveWithContext`, with a relative URL, to resolve a subpackage of
    ///   this package.
    /// * error indicates failure. See `ResolveError` for values and error
    ///   scenarios.
    pub fn r#resolve(
        &self,
        mut package_url: &str,
        mut dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
    ) -> fidl::client::QueryResponseFut<
        PackageResolverResolveResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        PackageResolverProxyInterface::r#resolve(self, package_url, dir)
    }

    /// Populates or updates the cache of a package using either an absolute or
    /// a relative package URL. If relative, the package will be resolved
    /// relative to the supplied `context`.
    ///
    /// Ensures that a package is on the local filesystem.
    ///
    /// + request `package_url` the absolute or relative package URL for a
    ///   package. If absolute, the `context` is ignored, and the behavior is
    ///   identical to calling `Resolve()`. A relative `package_url` is a
    ///   subpackage name.
    /// + request `context` a `ResolutionContext` associated with a previously
    ///   resolved package, for resolving subpackages relative to that package.
    /// + request `dir` a request for a directory that will be resolved when the
    ///   package has been successfully cached.
    /// + returns a `resolved_context`, which can be passed to a subsequent call
    ///   to `ResolveWithContext`, with a relative URL, to resolve a subpackage
    ///   of this package or subpackage.
    /// * error indicates failure. See `ResolveError` for values and error
    ///   scenarios.
    pub fn r#resolve_with_context(
        &self,
        mut package_url: &str,
        mut context: &ResolutionContext,
        mut dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
    ) -> fidl::client::QueryResponseFut<
        PackageResolverResolveWithContextResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        PackageResolverProxyInterface::r#resolve_with_context(self, package_url, context, dir)
    }

    /// Determines the hash of a package.
    ///
    /// + request `package_url` the package URL for a package.
    /// - response `meta_far_blob_id` the hash of the package.
    /// * error a zx_status value indicating failure. One of the following:
    ///     * `ZX_ERR_INTERNAL` if the resolver encountered an otherwise unspecified error
    ///       while handling the request.
    ///     * `ZX_ERR_NOT_FOUND` if the package does not exist in the repository specified by
    ///       `package_url`.
    ///     * `ZX_ERR_BAD_STATE` if the resolver does not know about the repository specified by
    ///       `package_url`.
    pub fn r#get_hash(
        &self,
        mut package_url: &PackageUrl,
    ) -> fidl::client::QueryResponseFut<
        PackageResolverGetHashResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        PackageResolverProxyInterface::r#get_hash(self, package_url)
    }
}

impl PackageResolverProxyInterface for PackageResolverProxy {
    type ResolveResponseFut = fidl::client::QueryResponseFut<
        PackageResolverResolveResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#resolve(
        &self,
        mut package_url: &str,
        mut dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
    ) -> Self::ResolveResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<PackageResolverResolveResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<PackageResolverResolveResponse, ResolveError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6611263be4052d4f,
            >(_buf?)?;
            Ok(_response.map(|x| x.resolved_context))
        }
        self.client
            .send_query_and_decode::<PackageResolverResolveRequest, PackageResolverResolveResult>(
                (package_url, dir),
                0x6611263be4052d4f,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type ResolveWithContextResponseFut = fidl::client::QueryResponseFut<
        PackageResolverResolveWithContextResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#resolve_with_context(
        &self,
        mut package_url: &str,
        mut context: &ResolutionContext,
        mut dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
    ) -> Self::ResolveWithContextResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<PackageResolverResolveWithContextResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<PackageResolverResolveWithContextResponse, ResolveError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4c255ae7260298d4,
            >(_buf?)?;
            Ok(_response.map(|x| x.resolved_context))
        }
        self.client.send_query_and_decode::<
            PackageResolverResolveWithContextRequest,
            PackageResolverResolveWithContextResult,
        >(
            (package_url, context, dir,),
            0x4c255ae7260298d4,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetHashResponseFut = fidl::client::QueryResponseFut<
        PackageResolverGetHashResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_hash(&self, mut package_url: &PackageUrl) -> Self::GetHashResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<PackageResolverGetHashResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<PackageResolverGetHashResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x594e8b4db51efd87,
            >(_buf?)?;
            Ok(_response.map(|x| x.meta_far_blob_id))
        }
        self.client
            .send_query_and_decode::<PackageResolverGetHashRequest, PackageResolverGetHashResult>(
                (package_url,),
                0x594e8b4db51efd87,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for PackageResolverRequestStream {
    type Protocol = PackageResolverMarker;
    type ControlHandle = PackageResolverControlHandle;

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x6611263be4052d4f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            PackageResolverResolveRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PackageResolverResolveRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            PackageResolverControlHandle { inner: this.inner.clone() };
                        Ok(PackageResolverRequest::Resolve {
                            package_url: req.package_url,
                            dir: req.dir,

                            responder: PackageResolverResolveResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4c255ae7260298d4 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            PackageResolverResolveWithContextRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PackageResolverResolveWithContextRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            PackageResolverControlHandle { inner: this.inner.clone() };
                        Ok(PackageResolverRequest::ResolveWithContext {
                            package_url: req.package_url,
                            context: req.context,
                            dir: req.dir,

                            responder: PackageResolverResolveWithContextResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x594e8b4db51efd87 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            PackageResolverGetHashRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PackageResolverGetHashRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            PackageResolverControlHandle { inner: this.inner.clone() };
                        Ok(PackageResolverRequest::GetHash {
                            package_url: req.package_url,

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

/// This resolves packages from a repository.
///
/// This is intended to be implemented by package resolver components, and used by
/// repository administration tools.
#[derive(Debug)]
pub enum PackageResolverRequest {
    /// Populates or updates the cache of a package using an absolute package
    /// URL.
    ///
    /// Ensures that a package, and any transitive subpackages, are on the local
    /// filesystem.
    ///
    /// + request `package_url` the absolute package URL for a package.  The
    ///   following link describes the format:
    ///   https://fuchsia.dev/fuchsia-src/concepts/packages/package_url.
    ///   Resource paths are not allowed.
    /// + request `dir` a request for a directory that will be resolved when the
    ///   package has been successfully cached.
    /// + returns a `resolved_context`, which can be passed to
    ///   `ResolveWithContext`, with a relative URL, to resolve a subpackage of
    ///   this package.
    /// * error indicates failure. See `ResolveError` for values and error
    ///   scenarios.
    Resolve {
        package_url: String,
        dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
        responder: PackageResolverResolveResponder,
    },
    /// Populates or updates the cache of a package using either an absolute or
    /// a relative package URL. If relative, the package will be resolved
    /// relative to the supplied `context`.
    ///
    /// Ensures that a package is on the local filesystem.
    ///
    /// + request `package_url` the absolute or relative package URL for a
    ///   package. If absolute, the `context` is ignored, and the behavior is
    ///   identical to calling `Resolve()`. A relative `package_url` is a
    ///   subpackage name.
    /// + request `context` a `ResolutionContext` associated with a previously
    ///   resolved package, for resolving subpackages relative to that package.
    /// + request `dir` a request for a directory that will be resolved when the
    ///   package has been successfully cached.
    /// + returns a `resolved_context`, which can be passed to a subsequent call
    ///   to `ResolveWithContext`, with a relative URL, to resolve a subpackage
    ///   of this package or subpackage.
    /// * error indicates failure. See `ResolveError` for values and error
    ///   scenarios.
    ResolveWithContext {
        package_url: String,
        context: ResolutionContext,
        dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
        responder: PackageResolverResolveWithContextResponder,
    },
    /// Determines the hash of a package.
    ///
    /// + request `package_url` the package URL for a package.
    /// - response `meta_far_blob_id` the hash of the package.
    /// * error a zx_status value indicating failure. One of the following:
    ///     * `ZX_ERR_INTERNAL` if the resolver encountered an otherwise unspecified error
    ///       while handling the request.
    ///     * `ZX_ERR_NOT_FOUND` if the package does not exist in the repository specified by
    ///       `package_url`.
    ///     * `ZX_ERR_BAD_STATE` if the resolver does not know about the repository specified by
    ///       `package_url`.
    GetHash { package_url: PackageUrl, responder: PackageResolverGetHashResponder },
}

impl PackageResolverRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_resolve(
        self,
    ) -> Option<(
        String,
        fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
        PackageResolverResolveResponder,
    )> {
        if let PackageResolverRequest::Resolve { package_url, dir, responder } = self {
            Some((package_url, dir, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_resolve_with_context(
        self,
    ) -> Option<(
        String,
        ResolutionContext,
        fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
        PackageResolverResolveWithContextResponder,
    )> {
        if let PackageResolverRequest::ResolveWithContext { package_url, context, dir, responder } =
            self
        {
            Some((package_url, context, dir, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_hash(self) -> Option<(PackageUrl, PackageResolverGetHashResponder)> {
        if let PackageResolverRequest::GetHash { package_url, responder } = self {
            Some((package_url, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            PackageResolverRequest::Resolve { .. } => "resolve",
            PackageResolverRequest::ResolveWithContext { .. } => "resolve_with_context",
            PackageResolverRequest::GetHash { .. } => "get_hash",
        }
    }
}

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

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

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

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        self.inner.shutdown_with_epitaph(status)
    }

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

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

impl PackageResolverControlHandle {}

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

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

impl fidl::endpoints::Responder for PackageResolverResolveResponder {
    type ControlHandle = PackageResolverControlHandle;

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

    fn send_raw(
        &self,
        mut result: Result<&ResolutionContext, ResolveError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            PackageResolverResolveResponse,
            ResolveError,
        >>(
            result.map(|resolved_context| (resolved_context,)),
            self.tx_id,
            0x6611263be4052d4f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

impl fidl::endpoints::Responder for PackageResolverResolveWithContextResponder {
    type ControlHandle = PackageResolverControlHandle;

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

    fn send_raw(
        &self,
        mut result: Result<&ResolutionContext, ResolveError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            PackageResolverResolveWithContextResponse,
            ResolveError,
        >>(
            result.map(|resolved_context| (resolved_context,)),
            self.tx_id,
            0x4c255ae7260298d4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

impl fidl::endpoints::Responder for PackageResolverGetHashResponder {
    type ControlHandle = PackageResolverControlHandle;

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

    fn send_raw(&self, mut result: Result<&BlobId, i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<PackageResolverGetHashResponse, i32>>(
                result.map(|meta_far_blob_id| (meta_far_blob_id,)),
                self.tx_id,
                0x594e8b4db51efd87,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

impl fidl::endpoints::ProtocolMarker for RepositoryIteratorMarker {
    type Proxy = RepositoryIteratorProxy;
    type RequestStream = RepositoryIteratorRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = RepositoryIteratorSynchronousProxy;

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

pub trait RepositoryIteratorProxyInterface: Send + Sync {
    type NextResponseFut: std::future::Future<Output = Result<Vec<RepositoryConfig>, fidl::Error>>
        + Send;
    fn r#next(&self) -> Self::NextResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct RepositoryIteratorSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for RepositoryIteratorSynchronousProxy {
    type Proxy = RepositoryIteratorProxy;
    type Protocol = RepositoryIteratorMarker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl RepositoryIteratorSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

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

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

    /// Advances the iterator and returns the next batch of repositories.
    ///
    /// - response `repos` a vector of `RepositoryConfig` repositories.
    ///   Will return an empty vector when there are no more repositories.
    pub fn r#next(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Vec<RepositoryConfig>, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            RepositoryIteratorNextResponse,
            RepositoryIteratorMarker,
        >(
            (),
            0x5502086bc0cdd25e,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.repos)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for RepositoryIteratorProxy {
    type Protocol = RepositoryIteratorMarker;

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

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

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

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

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

    /// Advances the iterator and returns the next batch of repositories.
    ///
    /// - response `repos` a vector of `RepositoryConfig` repositories.
    ///   Will return an empty vector when there are no more repositories.
    pub fn r#next(
        &self,
    ) -> fidl::client::QueryResponseFut<
        Vec<RepositoryConfig>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RepositoryIteratorProxyInterface::r#next(self)
    }
}

impl RepositoryIteratorProxyInterface for RepositoryIteratorProxy {
    type NextResponseFut = fidl::client::QueryResponseFut<
        Vec<RepositoryConfig>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#next(&self) -> Self::NextResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<RepositoryConfig>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                RepositoryIteratorNextResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5502086bc0cdd25e,
            >(_buf?)?;
            Ok(_response.repos)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<RepositoryConfig>>(
            (),
            0x5502086bc0cdd25e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for RepositoryIteratorRequestStream {
    type Protocol = RepositoryIteratorMarker;
    type ControlHandle = RepositoryIteratorControlHandle;

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                0x5502086bc0cdd25e => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = RepositoryIteratorControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(RepositoryIteratorRequest::Next {
                        responder: RepositoryIteratorNextResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <RepositoryIteratorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// The iterator over all the repositories defined in a `PackageResolver`.
#[derive(Debug)]
pub enum RepositoryIteratorRequest {
    /// Advances the iterator and returns the next batch of repositories.
    ///
    /// - response `repos` a vector of `RepositoryConfig` repositories.
    ///   Will return an empty vector when there are no more repositories.
    Next { responder: RepositoryIteratorNextResponder },
}

impl RepositoryIteratorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_next(self) -> Option<(RepositoryIteratorNextResponder)> {
        if let RepositoryIteratorRequest::Next { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

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

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

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

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

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        self.inner.shutdown_with_epitaph(status)
    }

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

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

impl RepositoryIteratorControlHandle {}

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

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

impl fidl::endpoints::Responder for RepositoryIteratorNextResponder {
    type ControlHandle = RepositoryIteratorControlHandle;

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

    fn send_raw(&self, mut repos: &[RepositoryConfig]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<RepositoryIteratorNextResponse>(
            (repos,),
            self.tx_id,
            0x5502086bc0cdd25e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for RepositoryManagerMarker {
    type Proxy = RepositoryManagerProxy;
    type RequestStream = RepositoryManagerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = RepositoryManagerSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.pkg.RepositoryManager";
}
impl fidl::endpoints::DiscoverableProtocolMarker for RepositoryManagerMarker {}
pub type RepositoryManagerAddResult = Result<(), i32>;
pub type RepositoryManagerRemoveResult = Result<(), i32>;
pub type RepositoryManagerAddMirrorResult = Result<(), i32>;
pub type RepositoryManagerRemoveMirrorResult = Result<(), i32>;

pub trait RepositoryManagerProxyInterface: Send + Sync {
    type AddResponseFut: std::future::Future<Output = Result<RepositoryManagerAddResult, fidl::Error>>
        + Send;
    fn r#add(&self, repo: &RepositoryConfig) -> Self::AddResponseFut;
    type RemoveResponseFut: std::future::Future<Output = Result<RepositoryManagerRemoveResult, fidl::Error>>
        + Send;
    fn r#remove(&self, repo_url: &str) -> Self::RemoveResponseFut;
    type AddMirrorResponseFut: std::future::Future<Output = Result<RepositoryManagerAddMirrorResult, fidl::Error>>
        + Send;
    fn r#add_mirror(&self, repo_url: &str, mirror: &MirrorConfig) -> Self::AddMirrorResponseFut;
    type RemoveMirrorResponseFut: std::future::Future<Output = Result<RepositoryManagerRemoveMirrorResult, fidl::Error>>
        + Send;
    fn r#remove_mirror(&self, repo_url: &str, mirror_url: &str) -> Self::RemoveMirrorResponseFut;
    fn r#list(
        &self,
        iterator: fidl::endpoints::ServerEnd<RepositoryIteratorMarker>,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct RepositoryManagerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for RepositoryManagerSynchronousProxy {
    type Proxy = RepositoryManagerProxy;
    type Protocol = RepositoryManagerMarker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl RepositoryManagerSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

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

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

    /// Adds a repository. This will overwrite the repository if it already exists.
    ///
    /// + request `repo` a repository to add to the resolver.
    /// * error a zx_status value indicating failure. One of the following:
    ///     * `ZX_ERR_ACCESS_DENIED` if editing repositories is permanently disabled.
    ///     * `ZX_ERR_ALREADY_EXISTS` if the repository already exists.
    ///     * `ZX_ERR_INVALID_ARGS` if the repository is malformed.
    pub fn r#add(
        &self,
        mut repo: &RepositoryConfig,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RepositoryManagerAddResult, fidl::Error> {
        let _response = self.client.send_query::<
            RepositoryManagerAddRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            RepositoryManagerMarker,
        >(
            (repo,),
            0x7fff4b8c733c7151,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Removes a repository.
    ///
    /// Removing a repository will prevent future packages from being cached from this repository,
    /// but in-flight downloads may not be interrupted.
    ///
    /// + request `repo_url` the URL of the repository we want to remove.
    /// * error a zx_status value indicating failure. One of the following:
    ///     * `ZX_ERR_ACCESS_DENIED` if editing repositories is permanently disabled or the
    ///       `repo_url` matches a static repository.
    ///     * `ZX_ERR_INVALID_ARGS` if the `repo_url` is malformed.
    ///     * `ZX_ERR_NOT_FOUND` if the repository does not exist.
    pub fn r#remove(
        &self,
        mut repo_url: &str,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RepositoryManagerRemoveResult, fidl::Error> {
        let _response = self.client.send_query::<
            RepositoryManagerRemoveRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            RepositoryManagerMarker,
        >(
            (repo_url,),
            0x5de23dc0e0dea4ba,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Adds a mirror to a repository. This will overwrite the mirror if it already exists.
    ///
    /// + request `repo_url` the URL of the repository to add the mirror to.
    /// + request `mirror` the mirror config used to add the mirror.
    /// * error a zx_status value indicating failure. One of the following:
    ///     * `ZX_ERR_ALREADY_EXISTS` if the mirror for this repository already exists.
    ///     * `ZX_ERR_INVALID_ARGS` if the `repo_url` or the `mirror` is malformed.
    ///     * `ZX_ERR_NOT_FOUND` if the repository does not exist.
    pub fn r#add_mirror(
        &self,
        mut repo_url: &str,
        mut mirror: &MirrorConfig,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RepositoryManagerAddMirrorResult, fidl::Error> {
        let _response = self.client.send_query::<
            RepositoryManagerAddMirrorRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            RepositoryManagerMarker,
        >(
            (repo_url, mirror,),
            0x3b7ef213730dd24c,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Removes a mirror from a repository.
    ///
    /// Removing a mirror will prevent future packages from being cached from that mirror, but
    /// in-flight downloads may not be interrupted.
    ///
    /// + request `repo_url` the URL of the mirror's repository.
    /// + request `mirror_url` the URL of the mirror we want to remove.
    /// * error a zx_status value indicating failure. One of the following:
    ///     * `ZX_ERR_INVALID_ARGS` if the `repo_url` or the `mirror_url` is malformed.
    ///     * `ZX_ERR_NOT_FOUND` if the repository or mirror does not exist.
    pub fn r#remove_mirror(
        &self,
        mut repo_url: &str,
        mut mirror_url: &str,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RepositoryManagerRemoveMirrorResult, fidl::Error> {
        let _response = self.client.send_query::<
            RepositoryManagerRemoveMirrorRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            RepositoryManagerMarker,
        >(
            (repo_url, mirror_url,),
            0x4682584cc47c23a2,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Returns an iterator over all repositories.
    ///
    /// + request `iterator` a request for an iterator.
    pub fn r#list(
        &self,
        mut iterator: fidl::endpoints::ServerEnd<RepositoryIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<RepositoryManagerListRequest>(
            (iterator,),
            0x61837314ba6f4afb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for RepositoryManagerProxy {
    type Protocol = RepositoryManagerMarker;

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

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

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

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

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

    /// Adds a repository. This will overwrite the repository if it already exists.
    ///
    /// + request `repo` a repository to add to the resolver.
    /// * error a zx_status value indicating failure. One of the following:
    ///     * `ZX_ERR_ACCESS_DENIED` if editing repositories is permanently disabled.
    ///     * `ZX_ERR_ALREADY_EXISTS` if the repository already exists.
    ///     * `ZX_ERR_INVALID_ARGS` if the repository is malformed.
    pub fn r#add(
        &self,
        mut repo: &RepositoryConfig,
    ) -> fidl::client::QueryResponseFut<
        RepositoryManagerAddResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RepositoryManagerProxyInterface::r#add(self, repo)
    }

    /// Removes a repository.
    ///
    /// Removing a repository will prevent future packages from being cached from this repository,
    /// but in-flight downloads may not be interrupted.
    ///
    /// + request `repo_url` the URL of the repository we want to remove.
    /// * error a zx_status value indicating failure. One of the following:
    ///     * `ZX_ERR_ACCESS_DENIED` if editing repositories is permanently disabled or the
    ///       `repo_url` matches a static repository.
    ///     * `ZX_ERR_INVALID_ARGS` if the `repo_url` is malformed.
    ///     * `ZX_ERR_NOT_FOUND` if the repository does not exist.
    pub fn r#remove(
        &self,
        mut repo_url: &str,
    ) -> fidl::client::QueryResponseFut<
        RepositoryManagerRemoveResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RepositoryManagerProxyInterface::r#remove(self, repo_url)
    }

    /// Adds a mirror to a repository. This will overwrite the mirror if it already exists.
    ///
    /// + request `repo_url` the URL of the repository to add the mirror to.
    /// + request `mirror` the mirror config used to add the mirror.
    /// * error a zx_status value indicating failure. One of the following:
    ///     * `ZX_ERR_ALREADY_EXISTS` if the mirror for this repository already exists.
    ///     * `ZX_ERR_INVALID_ARGS` if the `repo_url` or the `mirror` is malformed.
    ///     * `ZX_ERR_NOT_FOUND` if the repository does not exist.
    pub fn r#add_mirror(
        &self,
        mut repo_url: &str,
        mut mirror: &MirrorConfig,
    ) -> fidl::client::QueryResponseFut<
        RepositoryManagerAddMirrorResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RepositoryManagerProxyInterface::r#add_mirror(self, repo_url, mirror)
    }

    /// Removes a mirror from a repository.
    ///
    /// Removing a mirror will prevent future packages from being cached from that mirror, but
    /// in-flight downloads may not be interrupted.
    ///
    /// + request `repo_url` the URL of the mirror's repository.
    /// + request `mirror_url` the URL of the mirror we want to remove.
    /// * error a zx_status value indicating failure. One of the following:
    ///     * `ZX_ERR_INVALID_ARGS` if the `repo_url` or the `mirror_url` is malformed.
    ///     * `ZX_ERR_NOT_FOUND` if the repository or mirror does not exist.
    pub fn r#remove_mirror(
        &self,
        mut repo_url: &str,
        mut mirror_url: &str,
    ) -> fidl::client::QueryResponseFut<
        RepositoryManagerRemoveMirrorResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RepositoryManagerProxyInterface::r#remove_mirror(self, repo_url, mirror_url)
    }

    /// Returns an iterator over all repositories.
    ///
    /// + request `iterator` a request for an iterator.
    pub fn r#list(
        &self,
        mut iterator: fidl::endpoints::ServerEnd<RepositoryIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        RepositoryManagerProxyInterface::r#list(self, iterator)
    }
}

impl RepositoryManagerProxyInterface for RepositoryManagerProxy {
    type AddResponseFut = fidl::client::QueryResponseFut<
        RepositoryManagerAddResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#add(&self, mut repo: &RepositoryConfig) -> Self::AddResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RepositoryManagerAddResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7fff4b8c733c7151,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<RepositoryManagerAddRequest, RepositoryManagerAddResult>(
                (repo,),
                0x7fff4b8c733c7151,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type RemoveResponseFut = fidl::client::QueryResponseFut<
        RepositoryManagerRemoveResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#remove(&self, mut repo_url: &str) -> Self::RemoveResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RepositoryManagerRemoveResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5de23dc0e0dea4ba,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<RepositoryManagerRemoveRequest, RepositoryManagerRemoveResult>(
                (repo_url,),
                0x5de23dc0e0dea4ba,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type AddMirrorResponseFut = fidl::client::QueryResponseFut<
        RepositoryManagerAddMirrorResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#add_mirror(
        &self,
        mut repo_url: &str,
        mut mirror: &MirrorConfig,
    ) -> Self::AddMirrorResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RepositoryManagerAddMirrorResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3b7ef213730dd24c,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            RepositoryManagerAddMirrorRequest,
            RepositoryManagerAddMirrorResult,
        >(
            (repo_url, mirror,),
            0x3b7ef213730dd24c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type RemoveMirrorResponseFut = fidl::client::QueryResponseFut<
        RepositoryManagerRemoveMirrorResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#remove_mirror(
        &self,
        mut repo_url: &str,
        mut mirror_url: &str,
    ) -> Self::RemoveMirrorResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RepositoryManagerRemoveMirrorResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4682584cc47c23a2,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            RepositoryManagerRemoveMirrorRequest,
            RepositoryManagerRemoveMirrorResult,
        >(
            (repo_url, mirror_url,),
            0x4682584cc47c23a2,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#list(
        &self,
        mut iterator: fidl::endpoints::ServerEnd<RepositoryIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<RepositoryManagerListRequest>(
            (iterator,),
            0x61837314ba6f4afb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for RepositoryManagerRequestStream {
    type Protocol = RepositoryManagerMarker;
    type ControlHandle = RepositoryManagerControlHandle;

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x7fff4b8c733c7151 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RepositoryManagerAddRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RepositoryManagerAddRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            RepositoryManagerControlHandle { inner: this.inner.clone() };
                        Ok(RepositoryManagerRequest::Add {
                            repo: req.repo,

                            responder: RepositoryManagerAddResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5de23dc0e0dea4ba => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RepositoryManagerRemoveRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RepositoryManagerRemoveRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            RepositoryManagerControlHandle { inner: this.inner.clone() };
                        Ok(RepositoryManagerRequest::Remove {
                            repo_url: req.repo_url,

                            responder: RepositoryManagerRemoveResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3b7ef213730dd24c => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RepositoryManagerAddMirrorRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RepositoryManagerAddMirrorRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            RepositoryManagerControlHandle { inner: this.inner.clone() };
                        Ok(RepositoryManagerRequest::AddMirror {
                            repo_url: req.repo_url,
                            mirror: req.mirror,

                            responder: RepositoryManagerAddMirrorResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4682584cc47c23a2 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RepositoryManagerRemoveMirrorRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RepositoryManagerRemoveMirrorRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            RepositoryManagerControlHandle { inner: this.inner.clone() };
                        Ok(RepositoryManagerRequest::RemoveMirror {
                            repo_url: req.repo_url,
                            mirror_url: req.mirror_url,

                            responder: RepositoryManagerRemoveMirrorResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x61837314ba6f4afb => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            RepositoryManagerListRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RepositoryManagerListRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            RepositoryManagerControlHandle { inner: this.inner.clone() };
                        Ok(RepositoryManagerRequest::List {
                            iterator: req.iterator,

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

/// This manages package repositories.
///
/// This is intended to be implemented by package resolver components, and used by
/// repository administration tools.
#[derive(Debug)]
pub enum RepositoryManagerRequest {
    /// Adds a repository. This will overwrite the repository if it already exists.
    ///
    /// + request `repo` a repository to add to the resolver.
    /// * error a zx_status value indicating failure. One of the following:
    ///     * `ZX_ERR_ACCESS_DENIED` if editing repositories is permanently disabled.
    ///     * `ZX_ERR_ALREADY_EXISTS` if the repository already exists.
    ///     * `ZX_ERR_INVALID_ARGS` if the repository is malformed.
    Add { repo: RepositoryConfig, responder: RepositoryManagerAddResponder },
    /// Removes a repository.
    ///
    /// Removing a repository will prevent future packages from being cached from this repository,
    /// but in-flight downloads may not be interrupted.
    ///
    /// + request `repo_url` the URL of the repository we want to remove.
    /// * error a zx_status value indicating failure. One of the following:
    ///     * `ZX_ERR_ACCESS_DENIED` if editing repositories is permanently disabled or the
    ///       `repo_url` matches a static repository.
    ///     * `ZX_ERR_INVALID_ARGS` if the `repo_url` is malformed.
    ///     * `ZX_ERR_NOT_FOUND` if the repository does not exist.
    Remove { repo_url: String, responder: RepositoryManagerRemoveResponder },
    /// Adds a mirror to a repository. This will overwrite the mirror if it already exists.
    ///
    /// + request `repo_url` the URL of the repository to add the mirror to.
    /// + request `mirror` the mirror config used to add the mirror.
    /// * error a zx_status value indicating failure. One of the following:
    ///     * `ZX_ERR_ALREADY_EXISTS` if the mirror for this repository already exists.
    ///     * `ZX_ERR_INVALID_ARGS` if the `repo_url` or the `mirror` is malformed.
    ///     * `ZX_ERR_NOT_FOUND` if the repository does not exist.
    AddMirror {
        repo_url: String,
        mirror: MirrorConfig,
        responder: RepositoryManagerAddMirrorResponder,
    },
    /// Removes a mirror from a repository.
    ///
    /// Removing a mirror will prevent future packages from being cached from that mirror, but
    /// in-flight downloads may not be interrupted.
    ///
    /// + request `repo_url` the URL of the mirror's repository.
    /// + request `mirror_url` the URL of the mirror we want to remove.
    /// * error a zx_status value indicating failure. One of the following:
    ///     * `ZX_ERR_INVALID_ARGS` if the `repo_url` or the `mirror_url` is malformed.
    ///     * `ZX_ERR_NOT_FOUND` if the repository or mirror does not exist.
    RemoveMirror {
        repo_url: String,
        mirror_url: String,
        responder: RepositoryManagerRemoveMirrorResponder,
    },
    /// Returns an iterator over all repositories.
    ///
    /// + request `iterator` a request for an iterator.
    List {
        iterator: fidl::endpoints::ServerEnd<RepositoryIteratorMarker>,
        control_handle: RepositoryManagerControlHandle,
    },
}

impl RepositoryManagerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_add(self) -> Option<(RepositoryConfig, RepositoryManagerAddResponder)> {
        if let RepositoryManagerRequest::Add { repo, responder } = self {
            Some((repo, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_remove(self) -> Option<(String, RepositoryManagerRemoveResponder)> {
        if let RepositoryManagerRequest::Remove { repo_url, responder } = self {
            Some((repo_url, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_mirror(
        self,
    ) -> Option<(String, MirrorConfig, RepositoryManagerAddMirrorResponder)> {
        if let RepositoryManagerRequest::AddMirror { repo_url, mirror, responder } = self {
            Some((repo_url, mirror, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_remove_mirror(
        self,
    ) -> Option<(String, String, RepositoryManagerRemoveMirrorResponder)> {
        if let RepositoryManagerRequest::RemoveMirror { repo_url, mirror_url, responder } = self {
            Some((repo_url, mirror_url, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_list(
        self,
    ) -> Option<(
        fidl::endpoints::ServerEnd<RepositoryIteratorMarker>,
        RepositoryManagerControlHandle,
    )> {
        if let RepositoryManagerRequest::List { iterator, control_handle } = self {
            Some((iterator, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            RepositoryManagerRequest::Add { .. } => "add",
            RepositoryManagerRequest::Remove { .. } => "remove",
            RepositoryManagerRequest::AddMirror { .. } => "add_mirror",
            RepositoryManagerRequest::RemoveMirror { .. } => "remove_mirror",
            RepositoryManagerRequest::List { .. } => "list",
        }
    }
}

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

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

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

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        self.inner.shutdown_with_epitaph(status)
    }

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

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

impl RepositoryManagerControlHandle {}

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

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

impl fidl::endpoints::Responder for RepositoryManagerAddResponder {
    type ControlHandle = RepositoryManagerControlHandle;

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

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

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

impl fidl::endpoints::Responder for RepositoryManagerRemoveResponder {
    type ControlHandle = RepositoryManagerControlHandle;

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

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

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

impl fidl::endpoints::Responder for RepositoryManagerAddMirrorResponder {
    type ControlHandle = RepositoryManagerControlHandle;

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

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

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

impl fidl::endpoints::Responder for RepositoryManagerRemoveMirrorResponder {
    type ControlHandle = RepositoryManagerControlHandle;

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

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

impl fidl::endpoints::ProtocolMarker for RetainedBlobsMarker {
    type Proxy = RetainedBlobsProxy;
    type RequestStream = RetainedBlobsRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = RetainedBlobsSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.pkg.RetainedBlobs";
}
impl fidl::endpoints::DiscoverableProtocolMarker for RetainedBlobsMarker {}

pub trait RetainedBlobsProxyInterface: Send + Sync {
    type ClearResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#clear(&self) -> Self::ClearResponseFut;
    type ReplaceResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#replace(
        &self,
        iterator: fidl::endpoints::ClientEnd<BlobIdIteratorMarker>,
    ) -> Self::ReplaceResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct RetainedBlobsSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for RetainedBlobsSynchronousProxy {
    type Proxy = RetainedBlobsProxy;
    type Protocol = RetainedBlobsMarker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl RetainedBlobsSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

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

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

    /// Atomically clear the retained blob set, releasing any previously
    /// retained blobs.
    pub fn r#clear(&self, ___deadline: zx::MonotonicInstant) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::EmptyPayload,
            RetainedBlobsMarker,
        >(
            (),
            0x3005cab30c671164,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    /// Atomically replace the retained blob set with the blob hashes
    /// provided by the given iterator.
    /// Duplicate IDs provided will be merged and processed as a single one.
    ///
    /// + request `iterator` an iterator of blob IDs that should be
    ///   retained.
    pub fn r#replace(
        &self,
        mut iterator: fidl::endpoints::ClientEnd<BlobIdIteratorMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            RetainedBlobsReplaceRequest,
            fidl::encoding::EmptyPayload,
            RetainedBlobsMarker,
        >(
            (iterator,),
            0x2c049d51026cd0b3,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for RetainedBlobsProxy {
    type Protocol = RetainedBlobsMarker;

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

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

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

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

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

    /// Atomically clear the retained blob set, releasing any previously
    /// retained blobs.
    pub fn r#clear(
        &self,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        RetainedBlobsProxyInterface::r#clear(self)
    }

    /// Atomically replace the retained blob set with the blob hashes
    /// provided by the given iterator.
    /// Duplicate IDs provided will be merged and processed as a single one.
    ///
    /// + request `iterator` an iterator of blob IDs that should be
    ///   retained.
    pub fn r#replace(
        &self,
        mut iterator: fidl::endpoints::ClientEnd<BlobIdIteratorMarker>,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        RetainedBlobsProxyInterface::r#replace(self, iterator)
    }
}

impl RetainedBlobsProxyInterface for RetainedBlobsProxy {
    type ClearResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#clear(&self) -> Self::ClearResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3005cab30c671164,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
            (),
            0x3005cab30c671164,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ReplaceResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#replace(
        &self,
        mut iterator: fidl::endpoints::ClientEnd<BlobIdIteratorMarker>,
    ) -> Self::ReplaceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2c049d51026cd0b3,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<RetainedBlobsReplaceRequest, ()>(
            (iterator,),
            0x2c049d51026cd0b3,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for RetainedBlobsRequestStream {
    type Protocol = RetainedBlobsMarker;
    type ControlHandle = RetainedBlobsControlHandle;

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x3005cab30c671164 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            RetainedBlobsControlHandle { inner: this.inner.clone() };
                        Ok(RetainedBlobsRequest::Clear {
                            responder: RetainedBlobsClearResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2c049d51026cd0b3 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RetainedBlobsReplaceRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RetainedBlobsReplaceRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            RetainedBlobsControlHandle { inner: this.inner.clone() };
                        Ok(RetainedBlobsRequest::Replace {
                            iterator: req.iterator,

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

/// Manages the set of retained blobs.
///
/// Retained blobs will not be removed from the package cache, even if they
/// aren't fully present. There is only a single set active at once, and the
/// provided APIs for configuring the set atomically replace the retained blobs
/// set, it will not affect the retained packages set. On boot, the retained
/// blobs set is always initialized to the empty set.
/// Documentation on [garbage collection](
/// https://fuchsia.dev/fuchsia-src/concepts/packages/garbage_collection) contains
/// details on various types of package indexes (static, retained, etc) and
/// describes when a blob will be garbage collected or retained.
#[derive(Debug)]
pub enum RetainedBlobsRequest {
    /// Atomically clear the retained blob set, releasing any previously
    /// retained blobs.
    Clear { responder: RetainedBlobsClearResponder },
    /// Atomically replace the retained blob set with the blob hashes
    /// provided by the given iterator.
    /// Duplicate IDs provided will be merged and processed as a single one.
    ///
    /// + request `iterator` an iterator of blob IDs that should be
    ///   retained.
    Replace {
        iterator: fidl::endpoints::ClientEnd<BlobIdIteratorMarker>,
        responder: RetainedBlobsReplaceResponder,
    },
}

impl RetainedBlobsRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_clear(self) -> Option<(RetainedBlobsClearResponder)> {
        if let RetainedBlobsRequest::Clear { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_replace(
        self,
    ) -> Option<(fidl::endpoints::ClientEnd<BlobIdIteratorMarker>, RetainedBlobsReplaceResponder)>
    {
        if let RetainedBlobsRequest::Replace { iterator, responder } = self {
            Some((iterator, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            RetainedBlobsRequest::Clear { .. } => "clear",
            RetainedBlobsRequest::Replace { .. } => "replace",
        }
    }
}

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

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

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

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        self.inner.shutdown_with_epitaph(status)
    }

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

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

impl RetainedBlobsControlHandle {}

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

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

impl fidl::endpoints::Responder for RetainedBlobsClearResponder {
    type ControlHandle = RetainedBlobsControlHandle;

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

    fn send_raw(&self) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
            (),
            self.tx_id,
            0x3005cab30c671164,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

impl fidl::endpoints::Responder for RetainedBlobsReplaceResponder {
    type ControlHandle = RetainedBlobsControlHandle;

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

    fn send_raw(&self) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
            (),
            self.tx_id,
            0x2c049d51026cd0b3,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for RetainedPackagesMarker {
    type Proxy = RetainedPackagesProxy;
    type RequestStream = RetainedPackagesRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = RetainedPackagesSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.pkg.RetainedPackages";
}
impl fidl::endpoints::DiscoverableProtocolMarker for RetainedPackagesMarker {}

pub trait RetainedPackagesProxyInterface: Send + Sync {
    type ClearResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#clear(&self) -> Self::ClearResponseFut;
    type ReplaceResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#replace(
        &self,
        iterator: fidl::endpoints::ClientEnd<BlobIdIteratorMarker>,
    ) -> Self::ReplaceResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct RetainedPackagesSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for RetainedPackagesSynchronousProxy {
    type Proxy = RetainedPackagesProxy;
    type Protocol = RetainedPackagesMarker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl RetainedPackagesSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

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

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

    /// Atomically clear the retained package set, releasing any previously
    /// retained packages.
    pub fn r#clear(&self, ___deadline: zx::MonotonicInstant) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::EmptyPayload,
            RetainedPackagesMarker,
        >(
            (),
            0x7f17476f097961ac,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    /// Atomically replace the retained package set with the [package hashes](
    /// https://fuchsia.dev/fuchsia-src/concepts/packages/package_url#package-hash)
    /// provided by the given iterator.
    /// Duplicate IDs provided will be merged and processed as a single one.
    ///
    /// + request `iterator` an iterator of package blob IDs that should be
    ///   retained.
    pub fn r#replace(
        &self,
        mut iterator: fidl::endpoints::ClientEnd<BlobIdIteratorMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            RetainedPackagesReplaceRequest,
            fidl::encoding::EmptyPayload,
            RetainedPackagesMarker,
        >(
            (iterator,),
            0x5021e479570f3a9f,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for RetainedPackagesProxy {
    type Protocol = RetainedPackagesMarker;

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

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

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

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

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

    /// Atomically clear the retained package set, releasing any previously
    /// retained packages.
    pub fn r#clear(
        &self,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        RetainedPackagesProxyInterface::r#clear(self)
    }

    /// Atomically replace the retained package set with the [package hashes](
    /// https://fuchsia.dev/fuchsia-src/concepts/packages/package_url#package-hash)
    /// provided by the given iterator.
    /// Duplicate IDs provided will be merged and processed as a single one.
    ///
    /// + request `iterator` an iterator of package blob IDs that should be
    ///   retained.
    pub fn r#replace(
        &self,
        mut iterator: fidl::endpoints::ClientEnd<BlobIdIteratorMarker>,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        RetainedPackagesProxyInterface::r#replace(self, iterator)
    }
}

impl RetainedPackagesProxyInterface for RetainedPackagesProxy {
    type ClearResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#clear(&self) -> Self::ClearResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7f17476f097961ac,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
            (),
            0x7f17476f097961ac,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ReplaceResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#replace(
        &self,
        mut iterator: fidl::endpoints::ClientEnd<BlobIdIteratorMarker>,
    ) -> Self::ReplaceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5021e479570f3a9f,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<RetainedPackagesReplaceRequest, ()>(
            (iterator,),
            0x5021e479570f3a9f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for RetainedPackagesRequestStream {
    type Protocol = RetainedPackagesMarker;
    type ControlHandle = RetainedPackagesControlHandle;

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x7f17476f097961ac => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            RetainedPackagesControlHandle { inner: this.inner.clone() };
                        Ok(RetainedPackagesRequest::Clear {
                            responder: RetainedPackagesClearResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5021e479570f3a9f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RetainedPackagesReplaceRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RetainedPackagesReplaceRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            RetainedPackagesControlHandle { inner: this.inner.clone() };
                        Ok(RetainedPackagesRequest::Replace {
                            iterator: req.iterator,

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

/// Manages the set of retained packages.
///
/// Retained packages will not be removed from the package cache, even if they
/// aren't fully present. There is only a single set active at once, and the
/// provided APIs for configuring the set atomically replace the retained
/// packages set, it will not affect the retained blobs set. On boot, the
/// retained packages set is always initialized to the empty set.
/// Documentation on [garbage collection](
/// https://fuchsia.dev/fuchsia-src/concepts/packages/garbage_collection) contains
/// details on various types of package indexes (static, retained, etc) and
/// describes when a package will be garbage collected or retained.
#[derive(Debug)]
pub enum RetainedPackagesRequest {
    /// Atomically clear the retained package set, releasing any previously
    /// retained packages.
    Clear { responder: RetainedPackagesClearResponder },
    /// Atomically replace the retained package set with the [package hashes](
    /// https://fuchsia.dev/fuchsia-src/concepts/packages/package_url#package-hash)
    /// provided by the given iterator.
    /// Duplicate IDs provided will be merged and processed as a single one.
    ///
    /// + request `iterator` an iterator of package blob IDs that should be
    ///   retained.
    Replace {
        iterator: fidl::endpoints::ClientEnd<BlobIdIteratorMarker>,
        responder: RetainedPackagesReplaceResponder,
    },
}

impl RetainedPackagesRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_clear(self) -> Option<(RetainedPackagesClearResponder)> {
        if let RetainedPackagesRequest::Clear { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_replace(
        self,
    ) -> Option<(fidl::endpoints::ClientEnd<BlobIdIteratorMarker>, RetainedPackagesReplaceResponder)>
    {
        if let RetainedPackagesRequest::Replace { iterator, responder } = self {
            Some((iterator, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            RetainedPackagesRequest::Clear { .. } => "clear",
            RetainedPackagesRequest::Replace { .. } => "replace",
        }
    }
}

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

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

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

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        self.inner.shutdown_with_epitaph(status)
    }

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

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

impl RetainedPackagesControlHandle {}

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

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

impl fidl::endpoints::Responder for RetainedPackagesClearResponder {
    type ControlHandle = RetainedPackagesControlHandle;

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

    fn send_raw(&self) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
            (),
            self.tx_id,
            0x7f17476f097961ac,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

impl fidl::endpoints::Responder for RetainedPackagesReplaceResponder {
    type ControlHandle = RetainedPackagesControlHandle;

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

    fn send_raw(&self) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
            (),
            self.tx_id,
            0x5021e479570f3a9f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

mod internal {
    use super::*;

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            FontResolverResolveRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut FontResolverResolveRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FontResolverResolveRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                FontResolverResolveRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.package_url,
                    ),
                    <fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.directory_request,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::UnboundedString,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<
                    fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            FontResolverResolveRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FontResolverResolveRequest>(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(16);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for FontResolverResolveRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                package_url: fidl::new_empty!(
                    fidl::encoding::UnboundedString,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                directory_request: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
            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 + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl::encoding::UnboundedString,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.package_url,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<
                    fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.directory_request,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for NeededBlobsGetMissingBlobsRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                iterator: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<BlobInfoIteratorMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

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

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

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

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for PackageCacheBasePackageIndexRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                iterator: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<PackageIndexIteratorMarker>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for PackageCacheCachePackageIndexRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                iterator: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<PackageIndexIteratorMarker>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            PackageCacheGetRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut PackageCacheGetRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<PackageCacheGetRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<PackageCacheGetRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <BlobInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.meta_far_blob),
                    <GcProtection as fidl::encoding::ValueTypeMarker>::borrow(&self.gc_protection),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<NeededBlobsMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.needed_blobs),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.dir),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<BlobInfo, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<GcProtection, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T2: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<NeededBlobsMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T3: fidl::encoding::Encode<
                fidl::encoding::Endpoint<
                    fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            PackageCacheGetRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2, T3)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<PackageCacheGetRequest>(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(48);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 40, depth)?;
            self.2.encode(encoder, offset + 44, depth)?;
            self.3.encode(encoder, offset + 48, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for PackageCacheGetRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                meta_far_blob: fidl::new_empty!(
                    BlobInfo,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                gc_protection: fidl::new_empty!(
                    GcProtection,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                needed_blobs: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<NeededBlobsMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                dir: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(48) };
            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 + 48 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                BlobInfo,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.meta_far_blob,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                GcProtection,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.gc_protection,
                decoder,
                offset + 40,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<NeededBlobsMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.needed_blobs,
                decoder,
                offset + 44,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<
                    fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.dir,
                decoder,
                offset + 48,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            PackageCacheGetSubpackageRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut PackageCacheGetSubpackageRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<PackageCacheGetSubpackageRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                PackageCacheGetSubpackageRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <BlobId as fidl::encoding::ValueTypeMarker>::borrow(&self.superpackage),
                    <PackageUrl as fidl::encoding::ValueTypeMarker>::borrow(&self.subpackage),
                    <fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.dir
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<BlobId, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<PackageUrl, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T2: fidl::encoding::Encode<
                fidl::encoding::Endpoint<
                    fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            PackageCacheGetSubpackageRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<PackageCacheGetSubpackageRequest>(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(48);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 32, depth)?;
            self.2.encode(encoder, offset + 48, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for PackageCacheGetSubpackageRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                superpackage: fidl::new_empty!(
                    BlobId,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                subpackage: fidl::new_empty!(
                    PackageUrl,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                dir: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(48) };
            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 + 48 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                BlobId,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.superpackage,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                PackageUrl,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.subpackage,
                decoder,
                offset + 32,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<
                    fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.dir,
                decoder,
                offset + 48,
                _depth
            )?;
            Ok(())
        }
    }

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for PackageCacheWriteBlobsRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                needed_blobs: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<NeededBlobsMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            PackageResolverResolveRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut PackageResolverResolveRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<PackageResolverResolveRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                PackageResolverResolveRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.package_url,
                    ),
                    <fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.dir
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::UnboundedString,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<
                    fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            PackageResolverResolveRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<PackageResolverResolveRequest>(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(16);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for PackageResolverResolveRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                package_url: fidl::new_empty!(
                    fidl::encoding::UnboundedString,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                dir: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
            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 + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl::encoding::UnboundedString,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.package_url,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<
                    fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.dir,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            PackageResolverResolveWithContextRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut PackageResolverResolveWithContextRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<PackageResolverResolveWithContextRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                PackageResolverResolveWithContextRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.package_url,
                    ),
                    <ResolutionContext as fidl::encoding::ValueTypeMarker>::borrow(&self.context),
                    <fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.dir
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::UnboundedString,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T1: fidl::encoding::Encode<ResolutionContext, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T2: fidl::encoding::Encode<
                fidl::encoding::Endpoint<
                    fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            PackageResolverResolveWithContextRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<PackageResolverResolveWithContextRequest>(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(32);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            self.2.encode(encoder, offset + 32, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for PackageResolverResolveWithContextRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                package_url: fidl::new_empty!(
                    fidl::encoding::UnboundedString,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                context: fidl::new_empty!(
                    ResolutionContext,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                dir: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(32) };
            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 + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl::encoding::UnboundedString,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.package_url,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                ResolutionContext,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.context,
                decoder,
                offset + 16,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<
                    fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.dir,
                decoder,
                offset + 32,
                _depth
            )?;
            Ok(())
        }
    }

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for RepositoryManagerListRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                iterator: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<RepositoryIteratorMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

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

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

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

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

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

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