fidl_fuchsia_paver/

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DataSinkReadFirmwareRequest {
    pub configuration: Configuration,
    pub type_: String,
}

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

#[derive(Debug, PartialEq)]
pub struct DataSinkWriteAssetRequest {
    pub configuration: Configuration,
    pub asset: Asset,
    pub payload: fidl_fuchsia_mem::Buffer,
}

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

#[derive(Debug, PartialEq)]
pub struct DataSinkWriteFirmwareRequest {
    pub configuration: Configuration,
    pub type_: String,
    pub payload: fidl_fuchsia_mem::Buffer,
}

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

#[derive(Debug, PartialEq)]
pub struct DataSinkWriteOpaqueVolumeRequest {
    pub payload: fidl_fuchsia_mem::Buffer,
}

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

#[derive(Debug, PartialEq)]
pub struct DataSinkWriteSparseVolumeRequest {
    pub payload: fidl_fuchsia_mem::Buffer,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DataSinkWriteVolumesRequest {
    pub payload: fidl::endpoints::ClientEnd<PayloadStreamMarker>,
}

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

#[derive(Debug, PartialEq)]
pub struct DataSinkReadAssetResponse {
    pub asset: fidl_fuchsia_mem::Buffer,
}

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

#[derive(Debug, PartialEq)]
pub struct DataSinkReadFirmwareResponse {
    pub firmware: fidl_fuchsia_mem::Buffer,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct PaverFindBootManagerRequest {
    pub boot_manager: fidl::endpoints::ServerEnd<BootManagerMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct PaverFindDataSinkRequest {
    pub data_sink: fidl::endpoints::ServerEnd<DataSinkMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct PaverFindPartitionTableManagerRequest {
    pub data_sink: fidl::endpoints::ServerEnd<DynamicDataSinkMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct PaverFindSysconfigRequest {
    pub sysconfig: fidl::endpoints::ServerEnd<SysconfigMarker>,
}

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

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

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

#[derive(Debug, PartialEq)]
pub struct SysconfigWriteRequest {
    pub payload: fidl_fuchsia_mem::Buffer,
}

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

#[derive(Debug, PartialEq)]
pub struct SysconfigReadResponse {
    pub data: fidl_fuchsia_mem::Buffer,
}

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

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

impl fidl::endpoints::ProtocolMarker for BootManagerMarker {
    type Proxy = BootManagerProxy;
    type RequestStream = BootManagerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = BootManagerSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) BootManager";
}
pub type BootManagerQueryCurrentConfigurationResult = Result<Configuration, i32>;
pub type BootManagerQueryActiveConfigurationResult = Result<Configuration, i32>;
pub type BootManagerQueryConfigurationLastSetActiveResult = Result<Configuration, i32>;
pub type BootManagerQueryConfigurationStatusResult = Result<ConfigurationStatus, i32>;
pub type BootManagerQueryConfigurationStatusAndBootAttemptsResult =
    Result<BootManagerQueryConfigurationStatusAndBootAttemptsResponse, i32>;
pub type BootManagerSetOneShotRecoveryResult = Result<(), i32>;

pub trait BootManagerProxyInterface: Send + Sync {
    type QueryCurrentConfigurationResponseFut: std::future::Future<
            Output = Result<BootManagerQueryCurrentConfigurationResult, fidl::Error>,
        > + Send;
    fn r#query_current_configuration(&self) -> Self::QueryCurrentConfigurationResponseFut;
    type QueryActiveConfigurationResponseFut: std::future::Future<Output = Result<BootManagerQueryActiveConfigurationResult, fidl::Error>>
        + Send;
    fn r#query_active_configuration(&self) -> Self::QueryActiveConfigurationResponseFut;
    type QueryConfigurationLastSetActiveResponseFut: std::future::Future<
            Output = Result<BootManagerQueryConfigurationLastSetActiveResult, fidl::Error>,
        > + Send;
    fn r#query_configuration_last_set_active(
        &self,
    ) -> Self::QueryConfigurationLastSetActiveResponseFut;
    type QueryConfigurationStatusResponseFut: std::future::Future<Output = Result<BootManagerQueryConfigurationStatusResult, fidl::Error>>
        + Send;
    fn r#query_configuration_status(
        &self,
        configuration: Configuration,
    ) -> Self::QueryConfigurationStatusResponseFut;
    type QueryConfigurationStatusAndBootAttemptsResponseFut: std::future::Future<
            Output = Result<BootManagerQueryConfigurationStatusAndBootAttemptsResult, fidl::Error>,
        > + Send;
    fn r#query_configuration_status_and_boot_attempts(
        &self,
        configuration: Configuration,
    ) -> Self::QueryConfigurationStatusAndBootAttemptsResponseFut;
    type SetConfigurationActiveResponseFut: std::future::Future<Output = Result<i32, fidl::Error>>
        + Send;
    fn r#set_configuration_active(
        &self,
        configuration: Configuration,
    ) -> Self::SetConfigurationActiveResponseFut;
    type SetConfigurationUnbootableResponseFut: std::future::Future<Output = Result<i32, fidl::Error>>
        + Send;
    fn r#set_configuration_unbootable(
        &self,
        configuration: Configuration,
    ) -> Self::SetConfigurationUnbootableResponseFut;
    type SetConfigurationHealthyResponseFut: std::future::Future<Output = Result<i32, fidl::Error>>
        + Send;
    fn r#set_configuration_healthy(
        &self,
        configuration: Configuration,
    ) -> Self::SetConfigurationHealthyResponseFut;
    type SetOneShotRecoveryResponseFut: std::future::Future<Output = Result<BootManagerSetOneShotRecoveryResult, fidl::Error>>
        + Send;
    fn r#set_one_shot_recovery(&self) -> Self::SetOneShotRecoveryResponseFut;
    type FlushResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#flush(&self) -> Self::FlushResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct BootManagerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for BootManagerSynchronousProxy {
    type Proxy = BootManagerProxy;
    type Protocol = BootManagerMarker;

    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 BootManagerSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <BootManagerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

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

    /// Queries the configuration the system is currently running.
    ///
    /// Returns `ZX_ERR_NOT_SUPPORTED` if the `zvb.current_slot` boot argument cannot be read
    /// or is an unexpected value.
    pub fn r#query_current_configuration(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BootManagerQueryCurrentConfigurationResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BootManagerQueryCurrentConfigurationResponse,
                i32,
            >>(
                (),
                0xc213298cbc9c371,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.configuration))
    }

    /// Queries the configuration which will be used as the default boot choice on a normal cold
    /// boot, which may differ from the currently running configuration. `Configuration::RECOVERY`
    /// should never be active.
    ///
    /// Returns `ZX_ERR_NOT_SUPPORTED` if `Configuration.RECOVERY` is active.
    pub fn r#query_active_configuration(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BootManagerQueryActiveConfigurationResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BootManagerQueryActiveConfigurationResponse,
                i32,
            >>(
                (),
                0x71d52acdf59947a4,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.configuration))
    }

    /// Queries the configuration that was last explicitly marked as active by
    /// SetConfigurationActive(). The result is not affected by the current status of the slot.
    ///
    /// A newly updated slot is typically marked as active immediately. Therefore this interface
    /// can be used as a way to identify the newest slot.
    ///
    /// Returns `ZX_ERR_IO` if fail to load abr metadata. Returns `ZX_ERR_INTERNAL` if invalid
    /// slot index is returned by libabr routine.
    pub fn r#query_configuration_last_set_active(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BootManagerQueryConfigurationLastSetActiveResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BootManagerQueryConfigurationLastSetActiveResponse,
                i32,
            >>(
                (),
                0x6bcad87311b3345,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.configuration))
    }

    /// Queries status of `configuration`.
    ///
    /// Returns `ZX_ERR_INVALID_ARGS` if `Configuration.RECOVERY` is passed in via `configuration`.
    pub fn r#query_configuration_status(
        &self,
        mut configuration: Configuration,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BootManagerQueryConfigurationStatusResult, fidl::Error> {
        let _response = self.client.send_query::<
            BootManagerQueryConfigurationStatusRequest,
            fidl::encoding::ResultType<BootManagerQueryConfigurationStatusResponse, i32>,
        >(
            (configuration,),
            0x40822ca9ca68b19a,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.status))
    }

    /// Queries status of `configuration`.
    ///
    /// The returned table contains:
    ///
    /// * `status`: the current `ConfigurationStatus`
    ///
    /// * `boot_attempts`: if `status` is `ConfigurationStatus::PENDING`, this will be the number of
    ///   times this configuration has attempted to boot, including the current attempt. For any
    ///   other `status` this value will not be provided.
    ///
    ///   If provided, this value will be in the range `[0, MAX_PENDING_BOOT_ATTEMPTS]`. 0 indicates
    ///   the configuration was just set active and has not attempted any boots yet, and
    ///   `MAX_PENDING_BOOT_ATTEMPTS` indicates that all attempts have been used.
    ///
    /// * `unbootable_reason`: if `status` is `ConfigurationStatus::UNBOOTABLE`, this will be the
    ///   reported reason for why the configuration is unbootable. For any other `status` this value
    ///   will not be provided.
    ///
    /// Returns `ZX_ERR_INVALID_ARGS` if `Configuration.RECOVERY` is passed in via `configuration`.
    pub fn r#query_configuration_status_and_boot_attempts(
        &self,
        mut configuration: Configuration,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BootManagerQueryConfigurationStatusAndBootAttemptsResult, fidl::Error> {
        let _response = self.client.send_query::<
            BootManagerQueryConfigurationStatusAndBootAttemptsRequest,
            fidl::encoding::ResultType<BootManagerQueryConfigurationStatusAndBootAttemptsResponse, i32>,
        >(
            (configuration,),
            0x27f851d5809cfb3d,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Updates persistent metadata identifying which configuration should be selected as 'primary'
    /// for booting purposes. Should only be called after `KERNEL` as well as optional
    /// `VERIFIED_BOOT_METADATA` assets for specified `configuration` were written successfully.
    ///
    /// Also resets the boot attempts count for the given `Configuration`.
    ///
    /// Returns `ZX_ERR_INVALID_ARGS` if `Configuration.RECOVERY` is passed in via `configuration`.
    pub fn r#set_configuration_active(
        &self,
        mut configuration: Configuration,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<i32, fidl::Error> {
        let _response = self.client.send_query::<
            BootManagerSetConfigurationActiveRequest,
            BootManagerSetConfigurationActiveResponse,
        >(
            (configuration,),
            0x14c64074f81f9a7f,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.status)
    }

    /// Updates persistent metadata identifying whether `configuration` is bootable.
    /// Should only be called in the following situations:
    /// * Before `KERNEL` as well as optional `VERIFIED_BOOT_METADATA` assets for specified
    ///   `configuration` are written.
    /// * After successfully booting from a new configuration and marking it healthy. This method
    ///   would be then called on the old configuration.
    /// * After "successfully" booting from a new configuration, but encountering an unrecoverable
    ///   error during health check. This method would be then called on the new configuration.
    ///
    /// If the configuration is unbootable, no action is taken.
    ///
    /// Returns `ZX_ERR_INVALID_ARGS` if `Configuration.RECOVERY` is passed in via `configuration`.
    pub fn r#set_configuration_unbootable(
        &self,
        mut configuration: Configuration,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<i32, fidl::Error> {
        let _response = self.client.send_query::<
            BootManagerSetConfigurationUnbootableRequest,
            BootManagerSetConfigurationUnbootableResponse,
        >(
            (configuration,),
            0x6f8716bf306d197f,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.status)
    }

    /// Updates persistent metadata to mark a [`fuchsia.paver/Configuration`]
    /// as successful.
    ///
    /// This function is typically used by the OS update system after having
    /// confirmed that the configuration works as intended and the "rollback to
    /// previous slot" logic is not needed anymore.
    ///
    /// Compatibility between the newly successful configuration and the other
    /// configuration is unknown. Even if the other configuration was
    /// successful at one point, it may no longer be. This function adds a
    /// success mark to the given configuration but also removes any success
    /// mark on the other.
    ///
    /// If `configuration` is unbootable or is
    /// [`fuchsia.paver/Configuration.RECOVERY`], `response` will be
    /// `ZX_ERR_INVALID_ARGS`.
    ///
    /// + request `configuration` the `Configuration` to mark as healthy. Must
    ///   not be `RECOVERY`.
    /// - response `status` a zx_status value indicating success or failure.
    pub fn r#set_configuration_healthy(
        &self,
        mut configuration: Configuration,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<i32, fidl::Error> {
        let _response = self.client.send_query::<
            BootManagerSetConfigurationHealthyRequest,
            BootManagerSetConfigurationHealthyResponse,
        >(
            (configuration,),
            0x5dfe31714c8ec4be,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.status)
    }

    /// Force device to boot to recovery in the next reboot/power cycle. This will only be
    /// triggered once and will be reset after the reboot. State of A/B configuration slot will not
    /// be affected.
    pub fn r#set_one_shot_recovery(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BootManagerSetOneShotRecoveryResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (),
            0x7a5af0a28354f24d,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Flush all previously buffered writes to persistent storage.
    pub fn r#flush(&self, ___deadline: zx::MonotonicInstant) -> Result<i32, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, BootManagerFlushResponse>(
                (),
                0x2f29ec2322d62d3e,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.status)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for BootManagerProxy {
    type Protocol = BootManagerMarker;

    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 BootManagerProxy {
    /// Create a new Proxy for fuchsia.paver/BootManager.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <BootManagerMarker 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) -> BootManagerEventStream {
        BootManagerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Queries the configuration the system is currently running.
    ///
    /// Returns `ZX_ERR_NOT_SUPPORTED` if the `zvb.current_slot` boot argument cannot be read
    /// or is an unexpected value.
    pub fn r#query_current_configuration(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BootManagerQueryCurrentConfigurationResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BootManagerProxyInterface::r#query_current_configuration(self)
    }

    /// Queries the configuration which will be used as the default boot choice on a normal cold
    /// boot, which may differ from the currently running configuration. `Configuration::RECOVERY`
    /// should never be active.
    ///
    /// Returns `ZX_ERR_NOT_SUPPORTED` if `Configuration.RECOVERY` is active.
    pub fn r#query_active_configuration(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BootManagerQueryActiveConfigurationResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BootManagerProxyInterface::r#query_active_configuration(self)
    }

    /// Queries the configuration that was last explicitly marked as active by
    /// SetConfigurationActive(). The result is not affected by the current status of the slot.
    ///
    /// A newly updated slot is typically marked as active immediately. Therefore this interface
    /// can be used as a way to identify the newest slot.
    ///
    /// Returns `ZX_ERR_IO` if fail to load abr metadata. Returns `ZX_ERR_INTERNAL` if invalid
    /// slot index is returned by libabr routine.
    pub fn r#query_configuration_last_set_active(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BootManagerQueryConfigurationLastSetActiveResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BootManagerProxyInterface::r#query_configuration_last_set_active(self)
    }

    /// Queries status of `configuration`.
    ///
    /// Returns `ZX_ERR_INVALID_ARGS` if `Configuration.RECOVERY` is passed in via `configuration`.
    pub fn r#query_configuration_status(
        &self,
        mut configuration: Configuration,
    ) -> fidl::client::QueryResponseFut<
        BootManagerQueryConfigurationStatusResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BootManagerProxyInterface::r#query_configuration_status(self, configuration)
    }

    /// Queries status of `configuration`.
    ///
    /// The returned table contains:
    ///
    /// * `status`: the current `ConfigurationStatus`
    ///
    /// * `boot_attempts`: if `status` is `ConfigurationStatus::PENDING`, this will be the number of
    ///   times this configuration has attempted to boot, including the current attempt. For any
    ///   other `status` this value will not be provided.
    ///
    ///   If provided, this value will be in the range `[0, MAX_PENDING_BOOT_ATTEMPTS]`. 0 indicates
    ///   the configuration was just set active and has not attempted any boots yet, and
    ///   `MAX_PENDING_BOOT_ATTEMPTS` indicates that all attempts have been used.
    ///
    /// * `unbootable_reason`: if `status` is `ConfigurationStatus::UNBOOTABLE`, this will be the
    ///   reported reason for why the configuration is unbootable. For any other `status` this value
    ///   will not be provided.
    ///
    /// Returns `ZX_ERR_INVALID_ARGS` if `Configuration.RECOVERY` is passed in via `configuration`.
    pub fn r#query_configuration_status_and_boot_attempts(
        &self,
        mut configuration: Configuration,
    ) -> fidl::client::QueryResponseFut<
        BootManagerQueryConfigurationStatusAndBootAttemptsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BootManagerProxyInterface::r#query_configuration_status_and_boot_attempts(
            self,
            configuration,
        )
    }

    /// Updates persistent metadata identifying which configuration should be selected as 'primary'
    /// for booting purposes. Should only be called after `KERNEL` as well as optional
    /// `VERIFIED_BOOT_METADATA` assets for specified `configuration` were written successfully.
    ///
    /// Also resets the boot attempts count for the given `Configuration`.
    ///
    /// Returns `ZX_ERR_INVALID_ARGS` if `Configuration.RECOVERY` is passed in via `configuration`.
    pub fn r#set_configuration_active(
        &self,
        mut configuration: Configuration,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        BootManagerProxyInterface::r#set_configuration_active(self, configuration)
    }

    /// Updates persistent metadata identifying whether `configuration` is bootable.
    /// Should only be called in the following situations:
    /// * Before `KERNEL` as well as optional `VERIFIED_BOOT_METADATA` assets for specified
    ///   `configuration` are written.
    /// * After successfully booting from a new configuration and marking it healthy. This method
    ///   would be then called on the old configuration.
    /// * After "successfully" booting from a new configuration, but encountering an unrecoverable
    ///   error during health check. This method would be then called on the new configuration.
    ///
    /// If the configuration is unbootable, no action is taken.
    ///
    /// Returns `ZX_ERR_INVALID_ARGS` if `Configuration.RECOVERY` is passed in via `configuration`.
    pub fn r#set_configuration_unbootable(
        &self,
        mut configuration: Configuration,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        BootManagerProxyInterface::r#set_configuration_unbootable(self, configuration)
    }

    /// Updates persistent metadata to mark a [`fuchsia.paver/Configuration`]
    /// as successful.
    ///
    /// This function is typically used by the OS update system after having
    /// confirmed that the configuration works as intended and the "rollback to
    /// previous slot" logic is not needed anymore.
    ///
    /// Compatibility between the newly successful configuration and the other
    /// configuration is unknown. Even if the other configuration was
    /// successful at one point, it may no longer be. This function adds a
    /// success mark to the given configuration but also removes any success
    /// mark on the other.
    ///
    /// If `configuration` is unbootable or is
    /// [`fuchsia.paver/Configuration.RECOVERY`], `response` will be
    /// `ZX_ERR_INVALID_ARGS`.
    ///
    /// + request `configuration` the `Configuration` to mark as healthy. Must
    ///   not be `RECOVERY`.
    /// - response `status` a zx_status value indicating success or failure.
    pub fn r#set_configuration_healthy(
        &self,
        mut configuration: Configuration,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        BootManagerProxyInterface::r#set_configuration_healthy(self, configuration)
    }

    /// Force device to boot to recovery in the next reboot/power cycle. This will only be
    /// triggered once and will be reset after the reboot. State of A/B configuration slot will not
    /// be affected.
    pub fn r#set_one_shot_recovery(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BootManagerSetOneShotRecoveryResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BootManagerProxyInterface::r#set_one_shot_recovery(self)
    }

    /// Flush all previously buffered writes to persistent storage.
    pub fn r#flush(
        &self,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        BootManagerProxyInterface::r#flush(self)
    }
}

impl BootManagerProxyInterface for BootManagerProxy {
    type QueryCurrentConfigurationResponseFut = fidl::client::QueryResponseFut<
        BootManagerQueryCurrentConfigurationResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#query_current_configuration(&self) -> Self::QueryCurrentConfigurationResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BootManagerQueryCurrentConfigurationResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<BootManagerQueryCurrentConfigurationResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xc213298cbc9c371,
            >(_buf?)?;
            Ok(_response.map(|x| x.configuration))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BootManagerQueryCurrentConfigurationResult,
        >(
            (),
            0xc213298cbc9c371,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

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

    type QueryConfigurationStatusResponseFut = fidl::client::QueryResponseFut<
        BootManagerQueryConfigurationStatusResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#query_configuration_status(
        &self,
        mut configuration: Configuration,
    ) -> Self::QueryConfigurationStatusResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BootManagerQueryConfigurationStatusResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<BootManagerQueryConfigurationStatusResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x40822ca9ca68b19a,
            >(_buf?)?;
            Ok(_response.map(|x| x.status))
        }
        self.client.send_query_and_decode::<
            BootManagerQueryConfigurationStatusRequest,
            BootManagerQueryConfigurationStatusResult,
        >(
            (configuration,),
            0x40822ca9ca68b19a,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type QueryConfigurationStatusAndBootAttemptsResponseFut = fidl::client::QueryResponseFut<
        BootManagerQueryConfigurationStatusAndBootAttemptsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#query_configuration_status_and_boot_attempts(
        &self,
        mut configuration: Configuration,
    ) -> Self::QueryConfigurationStatusAndBootAttemptsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BootManagerQueryConfigurationStatusAndBootAttemptsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BootManagerQueryConfigurationStatusAndBootAttemptsResponse,
                    i32,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x27f851d5809cfb3d,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BootManagerQueryConfigurationStatusAndBootAttemptsRequest,
            BootManagerQueryConfigurationStatusAndBootAttemptsResult,
        >(
            (configuration,),
            0x27f851d5809cfb3d,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetConfigurationActiveResponseFut =
        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#set_configuration_active(
        &self,
        mut configuration: Configuration,
    ) -> Self::SetConfigurationActiveResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                BootManagerSetConfigurationActiveResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x14c64074f81f9a7f,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<BootManagerSetConfigurationActiveRequest, i32>(
            (configuration,),
            0x14c64074f81f9a7f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetConfigurationUnbootableResponseFut =
        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#set_configuration_unbootable(
        &self,
        mut configuration: Configuration,
    ) -> Self::SetConfigurationUnbootableResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                BootManagerSetConfigurationUnbootableResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6f8716bf306d197f,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<BootManagerSetConfigurationUnbootableRequest, i32>(
            (configuration,),
            0x6f8716bf306d197f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetConfigurationHealthyResponseFut =
        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#set_configuration_healthy(
        &self,
        mut configuration: Configuration,
    ) -> Self::SetConfigurationHealthyResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                BootManagerSetConfigurationHealthyResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5dfe31714c8ec4be,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<BootManagerSetConfigurationHealthyRequest, i32>(
            (configuration,),
            0x5dfe31714c8ec4be,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for BootManagerRequestStream {
    type Protocol = BootManagerMarker;
    type ControlHandle = BootManagerControlHandle;

    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 {
        BootManagerControlHandle { 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 BootManagerRequestStream {
    type Item = Result<BootManagerRequest, 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 BootManagerRequestStream 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 {
                    0xc213298cbc9c371 => {
                        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 = BootManagerControlHandle { inner: this.inner.clone() };
                        Ok(BootManagerRequest::QueryCurrentConfiguration {
                            responder: BootManagerQueryCurrentConfigurationResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x71d52acdf59947a4 => {
                        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 = BootManagerControlHandle { inner: this.inner.clone() };
                        Ok(BootManagerRequest::QueryActiveConfiguration {
                            responder: BootManagerQueryActiveConfigurationResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6bcad87311b3345 => {
                        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 = BootManagerControlHandle { inner: this.inner.clone() };
                        Ok(BootManagerRequest::QueryConfigurationLastSetActive {
                            responder: BootManagerQueryConfigurationLastSetActiveResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x40822ca9ca68b19a => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BootManagerQueryConfigurationStatusRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BootManagerQueryConfigurationStatusRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BootManagerControlHandle { inner: this.inner.clone() };
                        Ok(BootManagerRequest::QueryConfigurationStatus {
                            configuration: req.configuration,

                            responder: BootManagerQueryConfigurationStatusResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x27f851d5809cfb3d => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BootManagerQueryConfigurationStatusAndBootAttemptsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BootManagerQueryConfigurationStatusAndBootAttemptsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BootManagerControlHandle { inner: this.inner.clone() };
                        Ok(BootManagerRequest::QueryConfigurationStatusAndBootAttempts {
                            configuration: req.configuration,

                            responder:
                                BootManagerQueryConfigurationStatusAndBootAttemptsResponder {
                                    control_handle: std::mem::ManuallyDrop::new(control_handle),
                                    tx_id: header.tx_id,
                                },
                        })
                    }
                    0x14c64074f81f9a7f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BootManagerSetConfigurationActiveRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BootManagerSetConfigurationActiveRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BootManagerControlHandle { inner: this.inner.clone() };
                        Ok(BootManagerRequest::SetConfigurationActive {
                            configuration: req.configuration,

                            responder: BootManagerSetConfigurationActiveResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6f8716bf306d197f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BootManagerSetConfigurationUnbootableRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BootManagerSetConfigurationUnbootableRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BootManagerControlHandle { inner: this.inner.clone() };
                        Ok(BootManagerRequest::SetConfigurationUnbootable {
                            configuration: req.configuration,

                            responder: BootManagerSetConfigurationUnbootableResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5dfe31714c8ec4be => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BootManagerSetConfigurationHealthyRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BootManagerSetConfigurationHealthyRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BootManagerControlHandle { inner: this.inner.clone() };
                        Ok(BootManagerRequest::SetConfigurationHealthy {
                            configuration: req.configuration,

                            responder: BootManagerSetConfigurationHealthyResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7a5af0a28354f24d => {
                        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 = BootManagerControlHandle { inner: this.inner.clone() };
                        Ok(BootManagerRequest::SetOneShotRecovery {
                            responder: BootManagerSetOneShotRecoveryResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2f29ec2322d62d3e => {
                        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 = BootManagerControlHandle { inner: this.inner.clone() };
                        Ok(BootManagerRequest::Flush {
                            responder: BootManagerFlushResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <BootManagerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Protocol for managing boot configurations.
///
/// All functions will first check the A/B/R metadata and reset it to the default state if it's
/// invalid.
///
/// Operations which change the configuration are applied transactionally and will not be persisted
/// to storage until Flush() is called, at which point they will *all* be applied (or none at all).
/// If any of the operations fail (which is generally unexpected), the current set of changes may be
/// discarded.
///
/// The connection will be immediately closed with an epitaph of `ZX_ERR_NOT_SUPPORTED` if A/B/R is
/// not supported.
#[derive(Debug)]
pub enum BootManagerRequest {
    /// Queries the configuration the system is currently running.
    ///
    /// Returns `ZX_ERR_NOT_SUPPORTED` if the `zvb.current_slot` boot argument cannot be read
    /// or is an unexpected value.
    QueryCurrentConfiguration { responder: BootManagerQueryCurrentConfigurationResponder },
    /// Queries the configuration which will be used as the default boot choice on a normal cold
    /// boot, which may differ from the currently running configuration. `Configuration::RECOVERY`
    /// should never be active.
    ///
    /// Returns `ZX_ERR_NOT_SUPPORTED` if `Configuration.RECOVERY` is active.
    QueryActiveConfiguration { responder: BootManagerQueryActiveConfigurationResponder },
    /// Queries the configuration that was last explicitly marked as active by
    /// SetConfigurationActive(). The result is not affected by the current status of the slot.
    ///
    /// A newly updated slot is typically marked as active immediately. Therefore this interface
    /// can be used as a way to identify the newest slot.
    ///
    /// Returns `ZX_ERR_IO` if fail to load abr metadata. Returns `ZX_ERR_INTERNAL` if invalid
    /// slot index is returned by libabr routine.
    QueryConfigurationLastSetActive {
        responder: BootManagerQueryConfigurationLastSetActiveResponder,
    },
    /// Queries status of `configuration`.
    ///
    /// Returns `ZX_ERR_INVALID_ARGS` if `Configuration.RECOVERY` is passed in via `configuration`.
    QueryConfigurationStatus {
        configuration: Configuration,
        responder: BootManagerQueryConfigurationStatusResponder,
    },
    /// Queries status of `configuration`.
    ///
    /// The returned table contains:
    ///
    /// * `status`: the current `ConfigurationStatus`
    ///
    /// * `boot_attempts`: if `status` is `ConfigurationStatus::PENDING`, this will be the number of
    ///   times this configuration has attempted to boot, including the current attempt. For any
    ///   other `status` this value will not be provided.
    ///
    ///   If provided, this value will be in the range `[0, MAX_PENDING_BOOT_ATTEMPTS]`. 0 indicates
    ///   the configuration was just set active and has not attempted any boots yet, and
    ///   `MAX_PENDING_BOOT_ATTEMPTS` indicates that all attempts have been used.
    ///
    /// * `unbootable_reason`: if `status` is `ConfigurationStatus::UNBOOTABLE`, this will be the
    ///   reported reason for why the configuration is unbootable. For any other `status` this value
    ///   will not be provided.
    ///
    /// Returns `ZX_ERR_INVALID_ARGS` if `Configuration.RECOVERY` is passed in via `configuration`.
    QueryConfigurationStatusAndBootAttempts {
        configuration: Configuration,
        responder: BootManagerQueryConfigurationStatusAndBootAttemptsResponder,
    },
    /// Updates persistent metadata identifying which configuration should be selected as 'primary'
    /// for booting purposes. Should only be called after `KERNEL` as well as optional
    /// `VERIFIED_BOOT_METADATA` assets for specified `configuration` were written successfully.
    ///
    /// Also resets the boot attempts count for the given `Configuration`.
    ///
    /// Returns `ZX_ERR_INVALID_ARGS` if `Configuration.RECOVERY` is passed in via `configuration`.
    SetConfigurationActive {
        configuration: Configuration,
        responder: BootManagerSetConfigurationActiveResponder,
    },
    /// Updates persistent metadata identifying whether `configuration` is bootable.
    /// Should only be called in the following situations:
    /// * Before `KERNEL` as well as optional `VERIFIED_BOOT_METADATA` assets for specified
    ///   `configuration` are written.
    /// * After successfully booting from a new configuration and marking it healthy. This method
    ///   would be then called on the old configuration.
    /// * After "successfully" booting from a new configuration, but encountering an unrecoverable
    ///   error during health check. This method would be then called on the new configuration.
    ///
    /// If the configuration is unbootable, no action is taken.
    ///
    /// Returns `ZX_ERR_INVALID_ARGS` if `Configuration.RECOVERY` is passed in via `configuration`.
    SetConfigurationUnbootable {
        configuration: Configuration,
        responder: BootManagerSetConfigurationUnbootableResponder,
    },
    /// Updates persistent metadata to mark a [`fuchsia.paver/Configuration`]
    /// as successful.
    ///
    /// This function is typically used by the OS update system after having
    /// confirmed that the configuration works as intended and the "rollback to
    /// previous slot" logic is not needed anymore.
    ///
    /// Compatibility between the newly successful configuration and the other
    /// configuration is unknown. Even if the other configuration was
    /// successful at one point, it may no longer be. This function adds a
    /// success mark to the given configuration but also removes any success
    /// mark on the other.
    ///
    /// If `configuration` is unbootable or is
    /// [`fuchsia.paver/Configuration.RECOVERY`], `response` will be
    /// `ZX_ERR_INVALID_ARGS`.
    ///
    /// + request `configuration` the `Configuration` to mark as healthy. Must
    ///   not be `RECOVERY`.
    /// - response `status` a zx_status value indicating success or failure.
    SetConfigurationHealthy {
        configuration: Configuration,
        responder: BootManagerSetConfigurationHealthyResponder,
    },
    /// Force device to boot to recovery in the next reboot/power cycle. This will only be
    /// triggered once and will be reset after the reboot. State of A/B configuration slot will not
    /// be affected.
    SetOneShotRecovery { responder: BootManagerSetOneShotRecoveryResponder },
    /// Flush all previously buffered writes to persistent storage.
    Flush { responder: BootManagerFlushResponder },
}

impl BootManagerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_query_current_configuration(
        self,
    ) -> Option<(BootManagerQueryCurrentConfigurationResponder)> {
        if let BootManagerRequest::QueryCurrentConfiguration { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_query_active_configuration(
        self,
    ) -> Option<(BootManagerQueryActiveConfigurationResponder)> {
        if let BootManagerRequest::QueryActiveConfiguration { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_query_configuration_last_set_active(
        self,
    ) -> Option<(BootManagerQueryConfigurationLastSetActiveResponder)> {
        if let BootManagerRequest::QueryConfigurationLastSetActive { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_query_configuration_status(
        self,
    ) -> Option<(Configuration, BootManagerQueryConfigurationStatusResponder)> {
        if let BootManagerRequest::QueryConfigurationStatus { configuration, responder } = self {
            Some((configuration, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_query_configuration_status_and_boot_attempts(
        self,
    ) -> Option<(Configuration, BootManagerQueryConfigurationStatusAndBootAttemptsResponder)> {
        if let BootManagerRequest::QueryConfigurationStatusAndBootAttempts {
            configuration,
            responder,
        } = self
        {
            Some((configuration, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_configuration_active(
        self,
    ) -> Option<(Configuration, BootManagerSetConfigurationActiveResponder)> {
        if let BootManagerRequest::SetConfigurationActive { configuration, responder } = self {
            Some((configuration, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_configuration_unbootable(
        self,
    ) -> Option<(Configuration, BootManagerSetConfigurationUnbootableResponder)> {
        if let BootManagerRequest::SetConfigurationUnbootable { configuration, responder } = self {
            Some((configuration, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_configuration_healthy(
        self,
    ) -> Option<(Configuration, BootManagerSetConfigurationHealthyResponder)> {
        if let BootManagerRequest::SetConfigurationHealthy { configuration, responder } = self {
            Some((configuration, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_one_shot_recovery(self) -> Option<(BootManagerSetOneShotRecoveryResponder)> {
        if let BootManagerRequest::SetOneShotRecovery { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_flush(self) -> Option<(BootManagerFlushResponder)> {
        if let BootManagerRequest::Flush { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            BootManagerRequest::QueryCurrentConfiguration { .. } => "query_current_configuration",
            BootManagerRequest::QueryActiveConfiguration { .. } => "query_active_configuration",
            BootManagerRequest::QueryConfigurationLastSetActive { .. } => {
                "query_configuration_last_set_active"
            }
            BootManagerRequest::QueryConfigurationStatus { .. } => "query_configuration_status",
            BootManagerRequest::QueryConfigurationStatusAndBootAttempts { .. } => {
                "query_configuration_status_and_boot_attempts"
            }
            BootManagerRequest::SetConfigurationActive { .. } => "set_configuration_active",
            BootManagerRequest::SetConfigurationUnbootable { .. } => "set_configuration_unbootable",
            BootManagerRequest::SetConfigurationHealthy { .. } => "set_configuration_healthy",
            BootManagerRequest::SetOneShotRecovery { .. } => "set_one_shot_recovery",
            BootManagerRequest::Flush { .. } => "flush",
        }
    }
}

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

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

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

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

impl BootManagerControlHandle {}

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

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

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

    fn send_raw(&self, mut result: Result<Configuration, i32>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BootManagerQueryCurrentConfigurationResponse,
            i32,
        >>(
            result.map(|configuration| (configuration,)),
            self.tx_id,
            0xc213298cbc9c371,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut result: Result<Configuration, i32>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BootManagerQueryActiveConfigurationResponse,
            i32,
        >>(
            result.map(|configuration| (configuration,)),
            self.tx_id,
            0x71d52acdf59947a4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut result: Result<Configuration, i32>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BootManagerQueryConfigurationLastSetActiveResponse,
            i32,
        >>(
            result.map(|configuration| (configuration,)),
            self.tx_id,
            0x6bcad87311b3345,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut result: Result<ConfigurationStatus, i32>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BootManagerQueryConfigurationStatusResponse,
            i32,
        >>(
            result.map(|status| (status,)),
            self.tx_id,
            0x40822ca9ca68b19a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for DataSinkMarker {
    type Proxy = DataSinkProxy;
    type RequestStream = DataSinkRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = DataSinkSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) DataSink";
}
pub type DataSinkReadAssetResult = Result<fidl_fuchsia_mem::Buffer, i32>;
pub type DataSinkReadFirmwareResult = Result<fidl_fuchsia_mem::Buffer, i32>;
pub type DataSinkWriteOpaqueVolumeResult = Result<(), i32>;
pub type DataSinkWriteSparseVolumeResult = Result<(), i32>;

pub trait DataSinkProxyInterface: Send + Sync {
    type ReadAssetResponseFut: std::future::Future<Output = Result<DataSinkReadAssetResult, fidl::Error>>
        + Send;
    fn r#read_asset(
        &self,
        configuration: Configuration,
        asset: Asset,
    ) -> Self::ReadAssetResponseFut;
    type WriteAssetResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#write_asset(
        &self,
        configuration: Configuration,
        asset: Asset,
        payload: fidl_fuchsia_mem::Buffer,
    ) -> Self::WriteAssetResponseFut;
    type WriteFirmwareResponseFut: std::future::Future<Output = Result<WriteFirmwareResult, fidl::Error>>
        + Send;
    fn r#write_firmware(
        &self,
        configuration: Configuration,
        type_: &str,
        payload: fidl_fuchsia_mem::Buffer,
    ) -> Self::WriteFirmwareResponseFut;
    type ReadFirmwareResponseFut: std::future::Future<Output = Result<DataSinkReadFirmwareResult, fidl::Error>>
        + Send;
    fn r#read_firmware(
        &self,
        configuration: Configuration,
        type_: &str,
    ) -> Self::ReadFirmwareResponseFut;
    type WriteVolumesResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#write_volumes(
        &self,
        payload: fidl::endpoints::ClientEnd<PayloadStreamMarker>,
    ) -> Self::WriteVolumesResponseFut;
    type WriteOpaqueVolumeResponseFut: std::future::Future<Output = Result<DataSinkWriteOpaqueVolumeResult, fidl::Error>>
        + Send;
    fn r#write_opaque_volume(
        &self,
        payload: fidl_fuchsia_mem::Buffer,
    ) -> Self::WriteOpaqueVolumeResponseFut;
    type WriteSparseVolumeResponseFut: std::future::Future<Output = Result<DataSinkWriteSparseVolumeResult, fidl::Error>>
        + Send;
    fn r#write_sparse_volume(
        &self,
        payload: fidl_fuchsia_mem::Buffer,
    ) -> Self::WriteSparseVolumeResponseFut;
    type FlushResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#flush(&self) -> Self::FlushResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct DataSinkSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for DataSinkSynchronousProxy {
    type Proxy = DataSinkProxy;
    type Protocol = DataSinkMarker;

    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 DataSinkSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <DataSinkMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

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

    /// Reads the partition corresponding to `configuration` and `asset` into a vmo and returns it.
    /// The size field of the returned `Buffer` will be the size of just the asset, if it can be
    /// determined. Otherwise, it will be the size of the entire partition.
    /// The size and stream size of the vmo in the returned `Buffer` will always be the size of the
    /// entire partition.
    pub fn r#read_asset(
        &self,
        mut configuration: Configuration,
        mut asset: Asset,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DataSinkReadAssetResult, fidl::Error> {
        let _response = self.client.send_query::<
            DataSinkReadAssetRequest,
            fidl::encoding::ResultType<DataSinkReadAssetResponse, i32>,
        >(
            (configuration, asset,),
            0x125a23e561007898,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.asset))
    }

    /// Writes partition corresponding to `configuration` and `asset` with data from `payload`.
    /// `payload` may need to be resized to the partition size, so the provided vmo must have
    /// been created with `ZX_VMO_RESIZABLE` or must be a child VMO that was created with
    /// `ZX_VMO_CHILD_RESIZABLE`. Will zero out rest of the partition if `payload` is smaller
    /// than the size of the partition being written.
    ///
    ///
    /// Returns `ZX_ERR_INVALID_ARGS` if `configuration` specifies active configuration.
    pub fn r#write_asset(
        &self,
        mut configuration: Configuration,
        mut asset: Asset,
        mut payload: fidl_fuchsia_mem::Buffer,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<i32, fidl::Error> {
        let _response =
            self.client.send_query::<DataSinkWriteAssetRequest, DataSinkWriteAssetResponse>(
                (configuration, asset, &mut payload),
                0x516839ce76c4d0a9,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.status)
    }

    /// Writes firmware data from `payload`.
    ///
    /// `configuration` represents the A/B/R configuration. For platforms that do not support
    /// firmware A/B/R, the parameter will be ignored by the underlying device-specific logic .
    ///
    /// `type` is a device-specific string identifying the payload contents,
    /// used to select the proper paving logic. For example, a device with
    /// multiple bootloader stages might send them as separate calls to
    /// `WriteFirmware()`, differentiated by `type`. An empty string
    /// indicates the default type.
    ///
    /// `payload` may need to be resized to the partition size, so the provided
    /// vmo must have been created with `ZX_VMO_RESIZABLE` or must be a child
    /// VMO that was created with `ZX_VMO_CHILD_RESIZABLE`.
    pub fn r#write_firmware(
        &self,
        mut configuration: Configuration,
        mut type_: &str,
        mut payload: fidl_fuchsia_mem::Buffer,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<WriteFirmwareResult, fidl::Error> {
        let _response =
            self.client.send_query::<DataSinkWriteFirmwareRequest, DataSinkWriteFirmwareResponse>(
                (configuration, type_, &mut payload),
                0x514b93454ac0be97,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.result)
    }

    /// Read firmware corresponding to `configuration` and `type`.
    ///
    /// Parameter `configuration` and `type` are the same as WriteFirmware.
    ///
    /// If ReadFirmware returns error, caller should assume that firmware image does not exist
    /// or is in a bad state, or firmware read is not defined for the product.
    pub fn r#read_firmware(
        &self,
        mut configuration: Configuration,
        mut type_: &str,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DataSinkReadFirmwareResult, fidl::Error> {
        let _response = self.client.send_query::<
            DataSinkReadFirmwareRequest,
            fidl::encoding::ResultType<DataSinkReadFirmwareResponse, i32>,
        >(
            (configuration, type_,),
            0xcb67f9830cae9c3,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.firmware))
    }

    /// Writes FVM with data from streamed via `payload`. This potentially affects all
    /// configurations.
    pub fn r#write_volumes(
        &self,
        mut payload: fidl::endpoints::ClientEnd<PayloadStreamMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<i32, fidl::Error> {
        let _response =
            self.client.send_query::<DataSinkWriteVolumesRequest, DataSinkWriteVolumesResponse>(
                (payload,),
                0x5ee32c861d0259df,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.status)
    }

    /// Write a raw volume image to the device. The image will be passed as it is to the device
    /// partitioner backend to write. Therefore the format and write logic for the image is up to
    /// the product to define. It differs from WriteVolume(), which is specifically for writing the
    /// FVM sparse image, in that the paver will not perform any FVM related parsing or other
    /// operation of the image. Thus it is not dependent on the volume driver version and less
    /// susceptible to an outdated paver.
    ///
    /// Returns ZX_ERR_NOT_SUPPORTED if the backend does not support opaque volume blobs.
    pub fn r#write_opaque_volume(
        &self,
        mut payload: fidl_fuchsia_mem::Buffer,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DataSinkWriteOpaqueVolumeResult, fidl::Error> {
        let _response = self.client.send_query::<
            DataSinkWriteOpaqueVolumeRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (&mut payload,),
            0x4884b6ebaf660d79,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Writes an image in the Android Sparse format.  Identical in behaviour to
    /// `WriteOpaqueVolume`, except the contents of `payload` are parsed as a sparse image and
    /// unpacked before being written to disk.
    pub fn r#write_sparse_volume(
        &self,
        mut payload: fidl_fuchsia_mem::Buffer,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DataSinkWriteSparseVolumeResult, fidl::Error> {
        let _response = self.client.send_query::<
            DataSinkWriteSparseVolumeRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (&mut payload,),
            0x340f5370c5b1e026,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Flush all previously buffered writes to persistent storage.
    pub fn r#flush(&self, ___deadline: zx::MonotonicInstant) -> Result<i32, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, DataSinkFlushResponse>(
                (),
                0x3b59d3e2338e3139,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.status)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for DataSinkProxy {
    type Protocol = DataSinkMarker;

    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 DataSinkProxy {
    /// Create a new Proxy for fuchsia.paver/DataSink.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <DataSinkMarker 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) -> DataSinkEventStream {
        DataSinkEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Reads the partition corresponding to `configuration` and `asset` into a vmo and returns it.
    /// The size field of the returned `Buffer` will be the size of just the asset, if it can be
    /// determined. Otherwise, it will be the size of the entire partition.
    /// The size and stream size of the vmo in the returned `Buffer` will always be the size of the
    /// entire partition.
    pub fn r#read_asset(
        &self,
        mut configuration: Configuration,
        mut asset: Asset,
    ) -> fidl::client::QueryResponseFut<
        DataSinkReadAssetResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DataSinkProxyInterface::r#read_asset(self, configuration, asset)
    }

    /// Writes partition corresponding to `configuration` and `asset` with data from `payload`.
    /// `payload` may need to be resized to the partition size, so the provided vmo must have
    /// been created with `ZX_VMO_RESIZABLE` or must be a child VMO that was created with
    /// `ZX_VMO_CHILD_RESIZABLE`. Will zero out rest of the partition if `payload` is smaller
    /// than the size of the partition being written.
    ///
    ///
    /// Returns `ZX_ERR_INVALID_ARGS` if `configuration` specifies active configuration.
    pub fn r#write_asset(
        &self,
        mut configuration: Configuration,
        mut asset: Asset,
        mut payload: fidl_fuchsia_mem::Buffer,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        DataSinkProxyInterface::r#write_asset(self, configuration, asset, payload)
    }

    /// Writes firmware data from `payload`.
    ///
    /// `configuration` represents the A/B/R configuration. For platforms that do not support
    /// firmware A/B/R, the parameter will be ignored by the underlying device-specific logic .
    ///
    /// `type` is a device-specific string identifying the payload contents,
    /// used to select the proper paving logic. For example, a device with
    /// multiple bootloader stages might send them as separate calls to
    /// `WriteFirmware()`, differentiated by `type`. An empty string
    /// indicates the default type.
    ///
    /// `payload` may need to be resized to the partition size, so the provided
    /// vmo must have been created with `ZX_VMO_RESIZABLE` or must be a child
    /// VMO that was created with `ZX_VMO_CHILD_RESIZABLE`.
    pub fn r#write_firmware(
        &self,
        mut configuration: Configuration,
        mut type_: &str,
        mut payload: fidl_fuchsia_mem::Buffer,
    ) -> fidl::client::QueryResponseFut<
        WriteFirmwareResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DataSinkProxyInterface::r#write_firmware(self, configuration, type_, payload)
    }

    /// Read firmware corresponding to `configuration` and `type`.
    ///
    /// Parameter `configuration` and `type` are the same as WriteFirmware.
    ///
    /// If ReadFirmware returns error, caller should assume that firmware image does not exist
    /// or is in a bad state, or firmware read is not defined for the product.
    pub fn r#read_firmware(
        &self,
        mut configuration: Configuration,
        mut type_: &str,
    ) -> fidl::client::QueryResponseFut<
        DataSinkReadFirmwareResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DataSinkProxyInterface::r#read_firmware(self, configuration, type_)
    }

    /// Writes FVM with data from streamed via `payload`. This potentially affects all
    /// configurations.
    pub fn r#write_volumes(
        &self,
        mut payload: fidl::endpoints::ClientEnd<PayloadStreamMarker>,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        DataSinkProxyInterface::r#write_volumes(self, payload)
    }

    /// Write a raw volume image to the device. The image will be passed as it is to the device
    /// partitioner backend to write. Therefore the format and write logic for the image is up to
    /// the product to define. It differs from WriteVolume(), which is specifically for writing the
    /// FVM sparse image, in that the paver will not perform any FVM related parsing or other
    /// operation of the image. Thus it is not dependent on the volume driver version and less
    /// susceptible to an outdated paver.
    ///
    /// Returns ZX_ERR_NOT_SUPPORTED if the backend does not support opaque volume blobs.
    pub fn r#write_opaque_volume(
        &self,
        mut payload: fidl_fuchsia_mem::Buffer,
    ) -> fidl::client::QueryResponseFut<
        DataSinkWriteOpaqueVolumeResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DataSinkProxyInterface::r#write_opaque_volume(self, payload)
    }

    /// Writes an image in the Android Sparse format.  Identical in behaviour to
    /// `WriteOpaqueVolume`, except the contents of `payload` are parsed as a sparse image and
    /// unpacked before being written to disk.
    pub fn r#write_sparse_volume(
        &self,
        mut payload: fidl_fuchsia_mem::Buffer,
    ) -> fidl::client::QueryResponseFut<
        DataSinkWriteSparseVolumeResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DataSinkProxyInterface::r#write_sparse_volume(self, payload)
    }

    /// Flush all previously buffered writes to persistent storage.
    pub fn r#flush(
        &self,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        DataSinkProxyInterface::r#flush(self)
    }
}

impl DataSinkProxyInterface for DataSinkProxy {
    type ReadAssetResponseFut = fidl::client::QueryResponseFut<
        DataSinkReadAssetResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#read_asset(
        &self,
        mut configuration: Configuration,
        mut asset: Asset,
    ) -> Self::ReadAssetResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DataSinkReadAssetResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<DataSinkReadAssetResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x125a23e561007898,
            >(_buf?)?;
            Ok(_response.map(|x| x.asset))
        }
        self.client.send_query_and_decode::<DataSinkReadAssetRequest, DataSinkReadAssetResult>(
            (configuration, asset),
            0x125a23e561007898,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type WriteAssetResponseFut =
        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#write_asset(
        &self,
        mut configuration: Configuration,
        mut asset: Asset,
        mut payload: fidl_fuchsia_mem::Buffer,
    ) -> Self::WriteAssetResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DataSinkWriteAssetResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x516839ce76c4d0a9,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<DataSinkWriteAssetRequest, i32>(
            (configuration, asset, &mut payload),
            0x516839ce76c4d0a9,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type WriteFirmwareResponseFut = fidl::client::QueryResponseFut<
        WriteFirmwareResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#write_firmware(
        &self,
        mut configuration: Configuration,
        mut type_: &str,
        mut payload: fidl_fuchsia_mem::Buffer,
    ) -> Self::WriteFirmwareResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<WriteFirmwareResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DataSinkWriteFirmwareResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x514b93454ac0be97,
            >(_buf?)?;
            Ok(_response.result)
        }
        self.client.send_query_and_decode::<DataSinkWriteFirmwareRequest, WriteFirmwareResult>(
            (configuration, type_, &mut payload),
            0x514b93454ac0be97,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ReadFirmwareResponseFut = fidl::client::QueryResponseFut<
        DataSinkReadFirmwareResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#read_firmware(
        &self,
        mut configuration: Configuration,
        mut type_: &str,
    ) -> Self::ReadFirmwareResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DataSinkReadFirmwareResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<DataSinkReadFirmwareResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xcb67f9830cae9c3,
            >(_buf?)?;
            Ok(_response.map(|x| x.firmware))
        }
        self.client
            .send_query_and_decode::<DataSinkReadFirmwareRequest, DataSinkReadFirmwareResult>(
                (configuration, type_),
                0xcb67f9830cae9c3,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type WriteVolumesResponseFut =
        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#write_volumes(
        &self,
        mut payload: fidl::endpoints::ClientEnd<PayloadStreamMarker>,
    ) -> Self::WriteVolumesResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DataSinkWriteVolumesResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5ee32c861d0259df,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<DataSinkWriteVolumesRequest, i32>(
            (payload,),
            0x5ee32c861d0259df,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type WriteOpaqueVolumeResponseFut = fidl::client::QueryResponseFut<
        DataSinkWriteOpaqueVolumeResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#write_opaque_volume(
        &self,
        mut payload: fidl_fuchsia_mem::Buffer,
    ) -> Self::WriteOpaqueVolumeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DataSinkWriteOpaqueVolumeResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4884b6ebaf660d79,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            DataSinkWriteOpaqueVolumeRequest,
            DataSinkWriteOpaqueVolumeResult,
        >(
            (&mut payload,),
            0x4884b6ebaf660d79,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type WriteSparseVolumeResponseFut = fidl::client::QueryResponseFut<
        DataSinkWriteSparseVolumeResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#write_sparse_volume(
        &self,
        mut payload: fidl_fuchsia_mem::Buffer,
    ) -> Self::WriteSparseVolumeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DataSinkWriteSparseVolumeResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x340f5370c5b1e026,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            DataSinkWriteSparseVolumeRequest,
            DataSinkWriteSparseVolumeResult,
        >(
            (&mut payload,),
            0x340f5370c5b1e026,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for DataSinkRequestStream {
    type Protocol = DataSinkMarker;
    type ControlHandle = DataSinkControlHandle;

    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 {
        DataSinkControlHandle { 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 DataSinkRequestStream {
    type Item = Result<DataSinkRequest, 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 DataSinkRequestStream 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 {
                    0x125a23e561007898 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DataSinkReadAssetRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DataSinkReadAssetRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DataSinkControlHandle { inner: this.inner.clone() };
                        Ok(DataSinkRequest::ReadAsset {
                            configuration: req.configuration,
                            asset: req.asset,

                            responder: DataSinkReadAssetResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x516839ce76c4d0a9 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DataSinkWriteAssetRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DataSinkWriteAssetRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DataSinkControlHandle { inner: this.inner.clone() };
                        Ok(DataSinkRequest::WriteAsset {
                            configuration: req.configuration,
                            asset: req.asset,
                            payload: req.payload,

                            responder: DataSinkWriteAssetResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x514b93454ac0be97 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DataSinkWriteFirmwareRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DataSinkWriteFirmwareRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DataSinkControlHandle { inner: this.inner.clone() };
                        Ok(DataSinkRequest::WriteFirmware {
                            configuration: req.configuration,
                            type_: req.type_,
                            payload: req.payload,

                            responder: DataSinkWriteFirmwareResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0xcb67f9830cae9c3 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DataSinkReadFirmwareRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DataSinkReadFirmwareRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DataSinkControlHandle { inner: this.inner.clone() };
                        Ok(DataSinkRequest::ReadFirmware {
                            configuration: req.configuration,
                            type_: req.type_,

                            responder: DataSinkReadFirmwareResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5ee32c861d0259df => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DataSinkWriteVolumesRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DataSinkWriteVolumesRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DataSinkControlHandle { inner: this.inner.clone() };
                        Ok(DataSinkRequest::WriteVolumes {
                            payload: req.payload,

                            responder: DataSinkWriteVolumesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4884b6ebaf660d79 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DataSinkWriteOpaqueVolumeRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DataSinkWriteOpaqueVolumeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DataSinkControlHandle { inner: this.inner.clone() };
                        Ok(DataSinkRequest::WriteOpaqueVolume {
                            payload: req.payload,

                            responder: DataSinkWriteOpaqueVolumeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x340f5370c5b1e026 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DataSinkWriteSparseVolumeRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DataSinkWriteSparseVolumeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DataSinkControlHandle { inner: this.inner.clone() };
                        Ok(DataSinkRequest::WriteSparseVolume {
                            payload: req.payload,

                            responder: DataSinkWriteSparseVolumeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3b59d3e2338e3139 => {
                        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 = DataSinkControlHandle { inner: this.inner.clone() };
                        Ok(DataSinkRequest::Flush {
                            responder: DataSinkFlushResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <DataSinkMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Protocol for reading and writing boot partitions.
///
/// A note on DataSink.Flush() (and BootManager.Flush() coming after):
///
/// Some platforms may implement the Flush() fidl interface of DataSink/BootManager. For these
/// platforms, the update of some system images and A/B configuration is not persisted to storage
/// immediately and only buffered internally when the write fidl interfaces return. The data is
/// guaranteed to be persisted only after the Flush() interfaces are called.
///
/// If not implemented, Flush() is no-op and system images and A/B configuration will be persisted
/// to storage immediately after the write fidl interfaces return.
///
/// For all platforms, it is guaranteed that if DataSink.Flush() is implemented, BootManager.Flush()
/// is implemented as well. Therefore, in the context of system update, both of the following update
/// sequences are safe in the sense that, new A/B configuration will not be persisted to storage
/// before new system images.
/// DataSink.Write[...]() --> DataSink.Flush() --> BootManager.Set[...]() --> BootManager.Flush()
/// DataSink.Write[...]() --> BootManager.Set[...]() --> DataSink.Flush() --> BootManager.Flush()
#[derive(Debug)]
pub enum DataSinkRequest {
    /// Reads the partition corresponding to `configuration` and `asset` into a vmo and returns it.
    /// The size field of the returned `Buffer` will be the size of just the asset, if it can be
    /// determined. Otherwise, it will be the size of the entire partition.
    /// The size and stream size of the vmo in the returned `Buffer` will always be the size of the
    /// entire partition.
    ReadAsset { configuration: Configuration, asset: Asset, responder: DataSinkReadAssetResponder },
    /// Writes partition corresponding to `configuration` and `asset` with data from `payload`.
    /// `payload` may need to be resized to the partition size, so the provided vmo must have
    /// been created with `ZX_VMO_RESIZABLE` or must be a child VMO that was created with
    /// `ZX_VMO_CHILD_RESIZABLE`. Will zero out rest of the partition if `payload` is smaller
    /// than the size of the partition being written.
    ///
    ///
    /// Returns `ZX_ERR_INVALID_ARGS` if `configuration` specifies active configuration.
    WriteAsset {
        configuration: Configuration,
        asset: Asset,
        payload: fidl_fuchsia_mem::Buffer,
        responder: DataSinkWriteAssetResponder,
    },
    /// Writes firmware data from `payload`.
    ///
    /// `configuration` represents the A/B/R configuration. For platforms that do not support
    /// firmware A/B/R, the parameter will be ignored by the underlying device-specific logic .
    ///
    /// `type` is a device-specific string identifying the payload contents,
    /// used to select the proper paving logic. For example, a device with
    /// multiple bootloader stages might send them as separate calls to
    /// `WriteFirmware()`, differentiated by `type`. An empty string
    /// indicates the default type.
    ///
    /// `payload` may need to be resized to the partition size, so the provided
    /// vmo must have been created with `ZX_VMO_RESIZABLE` or must be a child
    /// VMO that was created with `ZX_VMO_CHILD_RESIZABLE`.
    WriteFirmware {
        configuration: Configuration,
        type_: String,
        payload: fidl_fuchsia_mem::Buffer,
        responder: DataSinkWriteFirmwareResponder,
    },
    /// Read firmware corresponding to `configuration` and `type`.
    ///
    /// Parameter `configuration` and `type` are the same as WriteFirmware.
    ///
    /// If ReadFirmware returns error, caller should assume that firmware image does not exist
    /// or is in a bad state, or firmware read is not defined for the product.
    ReadFirmware {
        configuration: Configuration,
        type_: String,
        responder: DataSinkReadFirmwareResponder,
    },
    /// Writes FVM with data from streamed via `payload`. This potentially affects all
    /// configurations.
    WriteVolumes {
        payload: fidl::endpoints::ClientEnd<PayloadStreamMarker>,
        responder: DataSinkWriteVolumesResponder,
    },
    /// Write a raw volume image to the device. The image will be passed as it is to the device
    /// partitioner backend to write. Therefore the format and write logic for the image is up to
    /// the product to define. It differs from WriteVolume(), which is specifically for writing the
    /// FVM sparse image, in that the paver will not perform any FVM related parsing or other
    /// operation of the image. Thus it is not dependent on the volume driver version and less
    /// susceptible to an outdated paver.
    ///
    /// Returns ZX_ERR_NOT_SUPPORTED if the backend does not support opaque volume blobs.
    WriteOpaqueVolume {
        payload: fidl_fuchsia_mem::Buffer,
        responder: DataSinkWriteOpaqueVolumeResponder,
    },
    /// Writes an image in the Android Sparse format.  Identical in behaviour to
    /// `WriteOpaqueVolume`, except the contents of `payload` are parsed as a sparse image and
    /// unpacked before being written to disk.
    WriteSparseVolume {
        payload: fidl_fuchsia_mem::Buffer,
        responder: DataSinkWriteSparseVolumeResponder,
    },
    /// Flush all previously buffered writes to persistent storage.
    Flush { responder: DataSinkFlushResponder },
}

impl DataSinkRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_read_asset(self) -> Option<(Configuration, Asset, DataSinkReadAssetResponder)> {
        if let DataSinkRequest::ReadAsset { configuration, asset, responder } = self {
            Some((configuration, asset, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_write_asset(
        self,
    ) -> Option<(Configuration, Asset, fidl_fuchsia_mem::Buffer, DataSinkWriteAssetResponder)> {
        if let DataSinkRequest::WriteAsset { configuration, asset, payload, responder } = self {
            Some((configuration, asset, payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_write_firmware(
        self,
    ) -> Option<(Configuration, String, fidl_fuchsia_mem::Buffer, DataSinkWriteFirmwareResponder)>
    {
        if let DataSinkRequest::WriteFirmware { configuration, type_, payload, responder } = self {
            Some((configuration, type_, payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_read_firmware(
        self,
    ) -> Option<(Configuration, String, DataSinkReadFirmwareResponder)> {
        if let DataSinkRequest::ReadFirmware { configuration, type_, responder } = self {
            Some((configuration, type_, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_write_volumes(
        self,
    ) -> Option<(fidl::endpoints::ClientEnd<PayloadStreamMarker>, DataSinkWriteVolumesResponder)>
    {
        if let DataSinkRequest::WriteVolumes { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_write_opaque_volume(
        self,
    ) -> Option<(fidl_fuchsia_mem::Buffer, DataSinkWriteOpaqueVolumeResponder)> {
        if let DataSinkRequest::WriteOpaqueVolume { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_write_sparse_volume(
        self,
    ) -> Option<(fidl_fuchsia_mem::Buffer, DataSinkWriteSparseVolumeResponder)> {
        if let DataSinkRequest::WriteSparseVolume { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_flush(self) -> Option<(DataSinkFlushResponder)> {
        if let DataSinkRequest::Flush { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            DataSinkRequest::ReadAsset { .. } => "read_asset",
            DataSinkRequest::WriteAsset { .. } => "write_asset",
            DataSinkRequest::WriteFirmware { .. } => "write_firmware",
            DataSinkRequest::ReadFirmware { .. } => "read_firmware",
            DataSinkRequest::WriteVolumes { .. } => "write_volumes",
            DataSinkRequest::WriteOpaqueVolume { .. } => "write_opaque_volume",
            DataSinkRequest::WriteSparseVolume { .. } => "write_sparse_volume",
            DataSinkRequest::Flush { .. } => "flush",
        }
    }
}

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

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

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

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

impl DataSinkControlHandle {}

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

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

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

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

    fn send_raw(
        &self,
        mut result: Result<fidl_fuchsia_mem::Buffer, i32>,
    ) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<DataSinkReadAssetResponse, i32>>(
                result.as_mut().map_err(|e| *e).map(|asset| (asset,)),
                self.tx_id,
                0x125a23e561007898,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut result: &WriteFirmwareResult) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<DataSinkWriteFirmwareResponse>(
            (result,),
            self.tx_id,
            0x514b93454ac0be97,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

    fn send_raw(
        &self,
        mut result: Result<fidl_fuchsia_mem::Buffer, i32>,
    ) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<DataSinkReadFirmwareResponse, i32>>(
                result.as_mut().map_err(|e| *e).map(|firmware| (firmware,)),
                self.tx_id,
                0xcb67f9830cae9c3,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for DynamicDataSinkMarker {
    type Proxy = DynamicDataSinkProxy;
    type RequestStream = DynamicDataSinkRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = DynamicDataSinkSynchronousProxy;

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

pub trait DynamicDataSinkProxyInterface: Send + Sync {
    type ReadAssetResponseFut: std::future::Future<Output = Result<DataSinkReadAssetResult, fidl::Error>>
        + Send;
    fn r#read_asset(
        &self,
        configuration: Configuration,
        asset: Asset,
    ) -> Self::ReadAssetResponseFut;
    type WriteAssetResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#write_asset(
        &self,
        configuration: Configuration,
        asset: Asset,
        payload: fidl_fuchsia_mem::Buffer,
    ) -> Self::WriteAssetResponseFut;
    type WriteFirmwareResponseFut: std::future::Future<Output = Result<WriteFirmwareResult, fidl::Error>>
        + Send;
    fn r#write_firmware(
        &self,
        configuration: Configuration,
        type_: &str,
        payload: fidl_fuchsia_mem::Buffer,
    ) -> Self::WriteFirmwareResponseFut;
    type ReadFirmwareResponseFut: std::future::Future<Output = Result<DataSinkReadFirmwareResult, fidl::Error>>
        + Send;
    fn r#read_firmware(
        &self,
        configuration: Configuration,
        type_: &str,
    ) -> Self::ReadFirmwareResponseFut;
    type WriteVolumesResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#write_volumes(
        &self,
        payload: fidl::endpoints::ClientEnd<PayloadStreamMarker>,
    ) -> Self::WriteVolumesResponseFut;
    type WriteOpaqueVolumeResponseFut: std::future::Future<Output = Result<DataSinkWriteOpaqueVolumeResult, fidl::Error>>
        + Send;
    fn r#write_opaque_volume(
        &self,
        payload: fidl_fuchsia_mem::Buffer,
    ) -> Self::WriteOpaqueVolumeResponseFut;
    type WriteSparseVolumeResponseFut: std::future::Future<Output = Result<DataSinkWriteSparseVolumeResult, fidl::Error>>
        + Send;
    fn r#write_sparse_volume(
        &self,
        payload: fidl_fuchsia_mem::Buffer,
    ) -> Self::WriteSparseVolumeResponseFut;
    type FlushResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#flush(&self) -> Self::FlushResponseFut;
    type InitializePartitionTablesResponseFut: std::future::Future<Output = Result<i32, fidl::Error>>
        + Send;
    fn r#initialize_partition_tables(&self) -> Self::InitializePartitionTablesResponseFut;
    type WipePartitionTablesResponseFut: std::future::Future<Output = Result<i32, fidl::Error>>
        + Send;
    fn r#wipe_partition_tables(&self) -> Self::WipePartitionTablesResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct DynamicDataSinkSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for DynamicDataSinkSynchronousProxy {
    type Proxy = DynamicDataSinkProxy;
    type Protocol = DynamicDataSinkMarker;

    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 DynamicDataSinkSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <DynamicDataSinkMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

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

    /// Reads the partition corresponding to `configuration` and `asset` into a vmo and returns it.
    /// The size field of the returned `Buffer` will be the size of just the asset, if it can be
    /// determined. Otherwise, it will be the size of the entire partition.
    /// The size and stream size of the vmo in the returned `Buffer` will always be the size of the
    /// entire partition.
    pub fn r#read_asset(
        &self,
        mut configuration: Configuration,
        mut asset: Asset,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DataSinkReadAssetResult, fidl::Error> {
        let _response = self.client.send_query::<
            DataSinkReadAssetRequest,
            fidl::encoding::ResultType<DataSinkReadAssetResponse, i32>,
        >(
            (configuration, asset,),
            0x125a23e561007898,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.asset))
    }

    /// Writes partition corresponding to `configuration` and `asset` with data from `payload`.
    /// `payload` may need to be resized to the partition size, so the provided vmo must have
    /// been created with `ZX_VMO_RESIZABLE` or must be a child VMO that was created with
    /// `ZX_VMO_CHILD_RESIZABLE`. Will zero out rest of the partition if `payload` is smaller
    /// than the size of the partition being written.
    ///
    ///
    /// Returns `ZX_ERR_INVALID_ARGS` if `configuration` specifies active configuration.
    pub fn r#write_asset(
        &self,
        mut configuration: Configuration,
        mut asset: Asset,
        mut payload: fidl_fuchsia_mem::Buffer,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<i32, fidl::Error> {
        let _response =
            self.client.send_query::<DataSinkWriteAssetRequest, DataSinkWriteAssetResponse>(
                (configuration, asset, &mut payload),
                0x516839ce76c4d0a9,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.status)
    }

    /// Writes firmware data from `payload`.
    ///
    /// `configuration` represents the A/B/R configuration. For platforms that do not support
    /// firmware A/B/R, the parameter will be ignored by the underlying device-specific logic .
    ///
    /// `type` is a device-specific string identifying the payload contents,
    /// used to select the proper paving logic. For example, a device with
    /// multiple bootloader stages might send them as separate calls to
    /// `WriteFirmware()`, differentiated by `type`. An empty string
    /// indicates the default type.
    ///
    /// `payload` may need to be resized to the partition size, so the provided
    /// vmo must have been created with `ZX_VMO_RESIZABLE` or must be a child
    /// VMO that was created with `ZX_VMO_CHILD_RESIZABLE`.
    pub fn r#write_firmware(
        &self,
        mut configuration: Configuration,
        mut type_: &str,
        mut payload: fidl_fuchsia_mem::Buffer,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<WriteFirmwareResult, fidl::Error> {
        let _response =
            self.client.send_query::<DataSinkWriteFirmwareRequest, DataSinkWriteFirmwareResponse>(
                (configuration, type_, &mut payload),
                0x514b93454ac0be97,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.result)
    }

    /// Read firmware corresponding to `configuration` and `type`.
    ///
    /// Parameter `configuration` and `type` are the same as WriteFirmware.
    ///
    /// If ReadFirmware returns error, caller should assume that firmware image does not exist
    /// or is in a bad state, or firmware read is not defined for the product.
    pub fn r#read_firmware(
        &self,
        mut configuration: Configuration,
        mut type_: &str,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DataSinkReadFirmwareResult, fidl::Error> {
        let _response = self.client.send_query::<
            DataSinkReadFirmwareRequest,
            fidl::encoding::ResultType<DataSinkReadFirmwareResponse, i32>,
        >(
            (configuration, type_,),
            0xcb67f9830cae9c3,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.firmware))
    }

    /// Writes FVM with data from streamed via `payload`. This potentially affects all
    /// configurations.
    pub fn r#write_volumes(
        &self,
        mut payload: fidl::endpoints::ClientEnd<PayloadStreamMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<i32, fidl::Error> {
        let _response =
            self.client.send_query::<DataSinkWriteVolumesRequest, DataSinkWriteVolumesResponse>(
                (payload,),
                0x5ee32c861d0259df,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.status)
    }

    /// Write a raw volume image to the device. The image will be passed as it is to the device
    /// partitioner backend to write. Therefore the format and write logic for the image is up to
    /// the product to define. It differs from WriteVolume(), which is specifically for writing the
    /// FVM sparse image, in that the paver will not perform any FVM related parsing or other
    /// operation of the image. Thus it is not dependent on the volume driver version and less
    /// susceptible to an outdated paver.
    ///
    /// Returns ZX_ERR_NOT_SUPPORTED if the backend does not support opaque volume blobs.
    pub fn r#write_opaque_volume(
        &self,
        mut payload: fidl_fuchsia_mem::Buffer,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DataSinkWriteOpaqueVolumeResult, fidl::Error> {
        let _response = self.client.send_query::<
            DataSinkWriteOpaqueVolumeRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (&mut payload,),
            0x4884b6ebaf660d79,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Writes an image in the Android Sparse format.  Identical in behaviour to
    /// `WriteOpaqueVolume`, except the contents of `payload` are parsed as a sparse image and
    /// unpacked before being written to disk.
    pub fn r#write_sparse_volume(
        &self,
        mut payload: fidl_fuchsia_mem::Buffer,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DataSinkWriteSparseVolumeResult, fidl::Error> {
        let _response = self.client.send_query::<
            DataSinkWriteSparseVolumeRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (&mut payload,),
            0x340f5370c5b1e026,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Flush all previously buffered writes to persistent storage.
    pub fn r#flush(&self, ___deadline: zx::MonotonicInstant) -> Result<i32, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, DataSinkFlushResponse>(
                (),
                0x3b59d3e2338e3139,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.status)
    }

    /// Initializes partitions on given block device.
    ///
    /// Currently only supported on devices which don't support fastboot (which is the preferred
    /// mechanism for device setup).
    ///
    /// *WARNING*: This API will wipe the existing partitions and data loss may occur.  Non-Fuchsia
    /// partitions *may* be preserved, although this is behaviour is board-specific.
    pub fn r#initialize_partition_tables(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<i32, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            DynamicDataSinkInitializePartitionTablesResponse,
        >(
            (),
            0x4c798b3813ea9f7e,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.status)
    }

    /// Wipes all entries from the partition table of the specified block device.
    /// Currently only supported on devices with a GPT.
    ///
    /// *WARNING*: This API may destructively remove non-fuchsia maintained partitions from
    /// the block device.
    pub fn r#wipe_partition_tables(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<i32, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, DynamicDataSinkWipePartitionTablesResponse>(
                (),
                0x797c0ebeedaf2cc,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.status)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for DynamicDataSinkProxy {
    type Protocol = DynamicDataSinkMarker;

    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 DynamicDataSinkProxy {
    /// Create a new Proxy for fuchsia.paver/DynamicDataSink.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <DynamicDataSinkMarker 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) -> DynamicDataSinkEventStream {
        DynamicDataSinkEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Reads the partition corresponding to `configuration` and `asset` into a vmo and returns it.
    /// The size field of the returned `Buffer` will be the size of just the asset, if it can be
    /// determined. Otherwise, it will be the size of the entire partition.
    /// The size and stream size of the vmo in the returned `Buffer` will always be the size of the
    /// entire partition.
    pub fn r#read_asset(
        &self,
        mut configuration: Configuration,
        mut asset: Asset,
    ) -> fidl::client::QueryResponseFut<
        DataSinkReadAssetResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DynamicDataSinkProxyInterface::r#read_asset(self, configuration, asset)
    }

    /// Writes partition corresponding to `configuration` and `asset` with data from `payload`.
    /// `payload` may need to be resized to the partition size, so the provided vmo must have
    /// been created with `ZX_VMO_RESIZABLE` or must be a child VMO that was created with
    /// `ZX_VMO_CHILD_RESIZABLE`. Will zero out rest of the partition if `payload` is smaller
    /// than the size of the partition being written.
    ///
    ///
    /// Returns `ZX_ERR_INVALID_ARGS` if `configuration` specifies active configuration.
    pub fn r#write_asset(
        &self,
        mut configuration: Configuration,
        mut asset: Asset,
        mut payload: fidl_fuchsia_mem::Buffer,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        DynamicDataSinkProxyInterface::r#write_asset(self, configuration, asset, payload)
    }

    /// Writes firmware data from `payload`.
    ///
    /// `configuration` represents the A/B/R configuration. For platforms that do not support
    /// firmware A/B/R, the parameter will be ignored by the underlying device-specific logic .
    ///
    /// `type` is a device-specific string identifying the payload contents,
    /// used to select the proper paving logic. For example, a device with
    /// multiple bootloader stages might send them as separate calls to
    /// `WriteFirmware()`, differentiated by `type`. An empty string
    /// indicates the default type.
    ///
    /// `payload` may need to be resized to the partition size, so the provided
    /// vmo must have been created with `ZX_VMO_RESIZABLE` or must be a child
    /// VMO that was created with `ZX_VMO_CHILD_RESIZABLE`.
    pub fn r#write_firmware(
        &self,
        mut configuration: Configuration,
        mut type_: &str,
        mut payload: fidl_fuchsia_mem::Buffer,
    ) -> fidl::client::QueryResponseFut<
        WriteFirmwareResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DynamicDataSinkProxyInterface::r#write_firmware(self, configuration, type_, payload)
    }

    /// Read firmware corresponding to `configuration` and `type`.
    ///
    /// Parameter `configuration` and `type` are the same as WriteFirmware.
    ///
    /// If ReadFirmware returns error, caller should assume that firmware image does not exist
    /// or is in a bad state, or firmware read is not defined for the product.
    pub fn r#read_firmware(
        &self,
        mut configuration: Configuration,
        mut type_: &str,
    ) -> fidl::client::QueryResponseFut<
        DataSinkReadFirmwareResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DynamicDataSinkProxyInterface::r#read_firmware(self, configuration, type_)
    }

    /// Writes FVM with data from streamed via `payload`. This potentially affects all
    /// configurations.
    pub fn r#write_volumes(
        &self,
        mut payload: fidl::endpoints::ClientEnd<PayloadStreamMarker>,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        DynamicDataSinkProxyInterface::r#write_volumes(self, payload)
    }

    /// Write a raw volume image to the device. The image will be passed as it is to the device
    /// partitioner backend to write. Therefore the format and write logic for the image is up to
    /// the product to define. It differs from WriteVolume(), which is specifically for writing the
    /// FVM sparse image, in that the paver will not perform any FVM related parsing or other
    /// operation of the image. Thus it is not dependent on the volume driver version and less
    /// susceptible to an outdated paver.
    ///
    /// Returns ZX_ERR_NOT_SUPPORTED if the backend does not support opaque volume blobs.
    pub fn r#write_opaque_volume(
        &self,
        mut payload: fidl_fuchsia_mem::Buffer,
    ) -> fidl::client::QueryResponseFut<
        DataSinkWriteOpaqueVolumeResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DynamicDataSinkProxyInterface::r#write_opaque_volume(self, payload)
    }

    /// Writes an image in the Android Sparse format.  Identical in behaviour to
    /// `WriteOpaqueVolume`, except the contents of `payload` are parsed as a sparse image and
    /// unpacked before being written to disk.
    pub fn r#write_sparse_volume(
        &self,
        mut payload: fidl_fuchsia_mem::Buffer,
    ) -> fidl::client::QueryResponseFut<
        DataSinkWriteSparseVolumeResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DynamicDataSinkProxyInterface::r#write_sparse_volume(self, payload)
    }

    /// Flush all previously buffered writes to persistent storage.
    pub fn r#flush(
        &self,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        DynamicDataSinkProxyInterface::r#flush(self)
    }

    /// Initializes partitions on given block device.
    ///
    /// Currently only supported on devices which don't support fastboot (which is the preferred
    /// mechanism for device setup).
    ///
    /// *WARNING*: This API will wipe the existing partitions and data loss may occur.  Non-Fuchsia
    /// partitions *may* be preserved, although this is behaviour is board-specific.
    pub fn r#initialize_partition_tables(
        &self,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        DynamicDataSinkProxyInterface::r#initialize_partition_tables(self)
    }

    /// Wipes all entries from the partition table of the specified block device.
    /// Currently only supported on devices with a GPT.
    ///
    /// *WARNING*: This API may destructively remove non-fuchsia maintained partitions from
    /// the block device.
    pub fn r#wipe_partition_tables(
        &self,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        DynamicDataSinkProxyInterface::r#wipe_partition_tables(self)
    }
}

impl DynamicDataSinkProxyInterface for DynamicDataSinkProxy {
    type ReadAssetResponseFut = fidl::client::QueryResponseFut<
        DataSinkReadAssetResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#read_asset(
        &self,
        mut configuration: Configuration,
        mut asset: Asset,
    ) -> Self::ReadAssetResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DataSinkReadAssetResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<DataSinkReadAssetResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x125a23e561007898,
            >(_buf?)?;
            Ok(_response.map(|x| x.asset))
        }
        self.client.send_query_and_decode::<DataSinkReadAssetRequest, DataSinkReadAssetResult>(
            (configuration, asset),
            0x125a23e561007898,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type WriteAssetResponseFut =
        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#write_asset(
        &self,
        mut configuration: Configuration,
        mut asset: Asset,
        mut payload: fidl_fuchsia_mem::Buffer,
    ) -> Self::WriteAssetResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DataSinkWriteAssetResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x516839ce76c4d0a9,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<DataSinkWriteAssetRequest, i32>(
            (configuration, asset, &mut payload),
            0x516839ce76c4d0a9,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type WriteFirmwareResponseFut = fidl::client::QueryResponseFut<
        WriteFirmwareResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#write_firmware(
        &self,
        mut configuration: Configuration,
        mut type_: &str,
        mut payload: fidl_fuchsia_mem::Buffer,
    ) -> Self::WriteFirmwareResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<WriteFirmwareResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DataSinkWriteFirmwareResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x514b93454ac0be97,
            >(_buf?)?;
            Ok(_response.result)
        }
        self.client.send_query_and_decode::<DataSinkWriteFirmwareRequest, WriteFirmwareResult>(
            (configuration, type_, &mut payload),
            0x514b93454ac0be97,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ReadFirmwareResponseFut = fidl::client::QueryResponseFut<
        DataSinkReadFirmwareResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#read_firmware(
        &self,
        mut configuration: Configuration,
        mut type_: &str,
    ) -> Self::ReadFirmwareResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DataSinkReadFirmwareResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<DataSinkReadFirmwareResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xcb67f9830cae9c3,
            >(_buf?)?;
            Ok(_response.map(|x| x.firmware))
        }
        self.client
            .send_query_and_decode::<DataSinkReadFirmwareRequest, DataSinkReadFirmwareResult>(
                (configuration, type_),
                0xcb67f9830cae9c3,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type WriteVolumesResponseFut =
        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#write_volumes(
        &self,
        mut payload: fidl::endpoints::ClientEnd<PayloadStreamMarker>,
    ) -> Self::WriteVolumesResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DataSinkWriteVolumesResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5ee32c861d0259df,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<DataSinkWriteVolumesRequest, i32>(
            (payload,),
            0x5ee32c861d0259df,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type WriteOpaqueVolumeResponseFut = fidl::client::QueryResponseFut<
        DataSinkWriteOpaqueVolumeResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#write_opaque_volume(
        &self,
        mut payload: fidl_fuchsia_mem::Buffer,
    ) -> Self::WriteOpaqueVolumeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DataSinkWriteOpaqueVolumeResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4884b6ebaf660d79,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            DataSinkWriteOpaqueVolumeRequest,
            DataSinkWriteOpaqueVolumeResult,
        >(
            (&mut payload,),
            0x4884b6ebaf660d79,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type WriteSparseVolumeResponseFut = fidl::client::QueryResponseFut<
        DataSinkWriteSparseVolumeResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#write_sparse_volume(
        &self,
        mut payload: fidl_fuchsia_mem::Buffer,
    ) -> Self::WriteSparseVolumeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DataSinkWriteSparseVolumeResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x340f5370c5b1e026,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            DataSinkWriteSparseVolumeRequest,
            DataSinkWriteSparseVolumeResult,
        >(
            (&mut payload,),
            0x340f5370c5b1e026,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

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

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for DynamicDataSinkRequestStream {
    type Protocol = DynamicDataSinkMarker;
    type ControlHandle = DynamicDataSinkControlHandle;

    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 {
        DynamicDataSinkControlHandle { 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 DynamicDataSinkRequestStream {
    type Item = Result<DynamicDataSinkRequest, 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 DynamicDataSinkRequestStream 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 {
                    0x125a23e561007898 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DataSinkReadAssetRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DataSinkReadAssetRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DynamicDataSinkControlHandle { inner: this.inner.clone() };
                        Ok(DynamicDataSinkRequest::ReadAsset {
                            configuration: req.configuration,
                            asset: req.asset,

                            responder: DynamicDataSinkReadAssetResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x516839ce76c4d0a9 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DataSinkWriteAssetRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DataSinkWriteAssetRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DynamicDataSinkControlHandle { inner: this.inner.clone() };
                        Ok(DynamicDataSinkRequest::WriteAsset {
                            configuration: req.configuration,
                            asset: req.asset,
                            payload: req.payload,

                            responder: DynamicDataSinkWriteAssetResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x514b93454ac0be97 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DataSinkWriteFirmwareRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DataSinkWriteFirmwareRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DynamicDataSinkControlHandle { inner: this.inner.clone() };
                        Ok(DynamicDataSinkRequest::WriteFirmware {
                            configuration: req.configuration,
                            type_: req.type_,
                            payload: req.payload,

                            responder: DynamicDataSinkWriteFirmwareResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0xcb67f9830cae9c3 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DataSinkReadFirmwareRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DataSinkReadFirmwareRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DynamicDataSinkControlHandle { inner: this.inner.clone() };
                        Ok(DynamicDataSinkRequest::ReadFirmware {
                            configuration: req.configuration,
                            type_: req.type_,

                            responder: DynamicDataSinkReadFirmwareResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5ee32c861d0259df => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DataSinkWriteVolumesRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DataSinkWriteVolumesRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DynamicDataSinkControlHandle { inner: this.inner.clone() };
                        Ok(DynamicDataSinkRequest::WriteVolumes {
                            payload: req.payload,

                            responder: DynamicDataSinkWriteVolumesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4884b6ebaf660d79 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DataSinkWriteOpaqueVolumeRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DataSinkWriteOpaqueVolumeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DynamicDataSinkControlHandle { inner: this.inner.clone() };
                        Ok(DynamicDataSinkRequest::WriteOpaqueVolume {
                            payload: req.payload,

                            responder: DynamicDataSinkWriteOpaqueVolumeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x340f5370c5b1e026 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DataSinkWriteSparseVolumeRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DataSinkWriteSparseVolumeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DynamicDataSinkControlHandle { inner: this.inner.clone() };
                        Ok(DynamicDataSinkRequest::WriteSparseVolume {
                            payload: req.payload,

                            responder: DynamicDataSinkWriteSparseVolumeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3b59d3e2338e3139 => {
                        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 =
                            DynamicDataSinkControlHandle { inner: this.inner.clone() };
                        Ok(DynamicDataSinkRequest::Flush {
                            responder: DynamicDataSinkFlushResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4c798b3813ea9f7e => {
                        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 =
                            DynamicDataSinkControlHandle { inner: this.inner.clone() };
                        Ok(DynamicDataSinkRequest::InitializePartitionTables {
                            responder: DynamicDataSinkInitializePartitionTablesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x797c0ebeedaf2cc => {
                        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 =
                            DynamicDataSinkControlHandle { inner: this.inner.clone() };
                        Ok(DynamicDataSinkRequest::WipePartitionTables {
                            responder: DynamicDataSinkWipePartitionTablesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <DynamicDataSinkMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Specialized DataSink with dynamic partition tables.
#[derive(Debug)]
pub enum DynamicDataSinkRequest {
    /// Reads the partition corresponding to `configuration` and `asset` into a vmo and returns it.
    /// The size field of the returned `Buffer` will be the size of just the asset, if it can be
    /// determined. Otherwise, it will be the size of the entire partition.
    /// The size and stream size of the vmo in the returned `Buffer` will always be the size of the
    /// entire partition.
    ReadAsset {
        configuration: Configuration,
        asset: Asset,
        responder: DynamicDataSinkReadAssetResponder,
    },
    /// Writes partition corresponding to `configuration` and `asset` with data from `payload`.
    /// `payload` may need to be resized to the partition size, so the provided vmo must have
    /// been created with `ZX_VMO_RESIZABLE` or must be a child VMO that was created with
    /// `ZX_VMO_CHILD_RESIZABLE`. Will zero out rest of the partition if `payload` is smaller
    /// than the size of the partition being written.
    ///
    ///
    /// Returns `ZX_ERR_INVALID_ARGS` if `configuration` specifies active configuration.
    WriteAsset {
        configuration: Configuration,
        asset: Asset,
        payload: fidl_fuchsia_mem::Buffer,
        responder: DynamicDataSinkWriteAssetResponder,
    },
    /// Writes firmware data from `payload`.
    ///
    /// `configuration` represents the A/B/R configuration. For platforms that do not support
    /// firmware A/B/R, the parameter will be ignored by the underlying device-specific logic .
    ///
    /// `type` is a device-specific string identifying the payload contents,
    /// used to select the proper paving logic. For example, a device with
    /// multiple bootloader stages might send them as separate calls to
    /// `WriteFirmware()`, differentiated by `type`. An empty string
    /// indicates the default type.
    ///
    /// `payload` may need to be resized to the partition size, so the provided
    /// vmo must have been created with `ZX_VMO_RESIZABLE` or must be a child
    /// VMO that was created with `ZX_VMO_CHILD_RESIZABLE`.
    WriteFirmware {
        configuration: Configuration,
        type_: String,
        payload: fidl_fuchsia_mem::Buffer,
        responder: DynamicDataSinkWriteFirmwareResponder,
    },
    /// Read firmware corresponding to `configuration` and `type`.
    ///
    /// Parameter `configuration` and `type` are the same as WriteFirmware.
    ///
    /// If ReadFirmware returns error, caller should assume that firmware image does not exist
    /// or is in a bad state, or firmware read is not defined for the product.
    ReadFirmware {
        configuration: Configuration,
        type_: String,
        responder: DynamicDataSinkReadFirmwareResponder,
    },
    /// Writes FVM with data from streamed via `payload`. This potentially affects all
    /// configurations.
    WriteVolumes {
        payload: fidl::endpoints::ClientEnd<PayloadStreamMarker>,
        responder: DynamicDataSinkWriteVolumesResponder,
    },
    /// Write a raw volume image to the device. The image will be passed as it is to the device
    /// partitioner backend to write. Therefore the format and write logic for the image is up to
    /// the product to define. It differs from WriteVolume(), which is specifically for writing the
    /// FVM sparse image, in that the paver will not perform any FVM related parsing or other
    /// operation of the image. Thus it is not dependent on the volume driver version and less
    /// susceptible to an outdated paver.
    ///
    /// Returns ZX_ERR_NOT_SUPPORTED if the backend does not support opaque volume blobs.
    WriteOpaqueVolume {
        payload: fidl_fuchsia_mem::Buffer,
        responder: DynamicDataSinkWriteOpaqueVolumeResponder,
    },
    /// Writes an image in the Android Sparse format.  Identical in behaviour to
    /// `WriteOpaqueVolume`, except the contents of `payload` are parsed as a sparse image and
    /// unpacked before being written to disk.
    WriteSparseVolume {
        payload: fidl_fuchsia_mem::Buffer,
        responder: DynamicDataSinkWriteSparseVolumeResponder,
    },
    /// Flush all previously buffered writes to persistent storage.
    Flush { responder: DynamicDataSinkFlushResponder },
    /// Initializes partitions on given block device.
    ///
    /// Currently only supported on devices which don't support fastboot (which is the preferred
    /// mechanism for device setup).
    ///
    /// *WARNING*: This API will wipe the existing partitions and data loss may occur.  Non-Fuchsia
    /// partitions *may* be preserved, although this is behaviour is board-specific.
    InitializePartitionTables { responder: DynamicDataSinkInitializePartitionTablesResponder },
    /// Wipes all entries from the partition table of the specified block device.
    /// Currently only supported on devices with a GPT.
    ///
    /// *WARNING*: This API may destructively remove non-fuchsia maintained partitions from
    /// the block device.
    WipePartitionTables { responder: DynamicDataSinkWipePartitionTablesResponder },
}

impl DynamicDataSinkRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_read_asset(
        self,
    ) -> Option<(Configuration, Asset, DynamicDataSinkReadAssetResponder)> {
        if let DynamicDataSinkRequest::ReadAsset { configuration, asset, responder } = self {
            Some((configuration, asset, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_write_asset(
        self,
    ) -> Option<(Configuration, Asset, fidl_fuchsia_mem::Buffer, DynamicDataSinkWriteAssetResponder)>
    {
        if let DynamicDataSinkRequest::WriteAsset { configuration, asset, payload, responder } =
            self
        {
            Some((configuration, asset, payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_write_firmware(
        self,
    ) -> Option<(
        Configuration,
        String,
        fidl_fuchsia_mem::Buffer,
        DynamicDataSinkWriteFirmwareResponder,
    )> {
        if let DynamicDataSinkRequest::WriteFirmware { configuration, type_, payload, responder } =
            self
        {
            Some((configuration, type_, payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_read_firmware(
        self,
    ) -> Option<(Configuration, String, DynamicDataSinkReadFirmwareResponder)> {
        if let DynamicDataSinkRequest::ReadFirmware { configuration, type_, responder } = self {
            Some((configuration, type_, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_write_volumes(
        self,
    ) -> Option<(
        fidl::endpoints::ClientEnd<PayloadStreamMarker>,
        DynamicDataSinkWriteVolumesResponder,
    )> {
        if let DynamicDataSinkRequest::WriteVolumes { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_write_opaque_volume(
        self,
    ) -> Option<(fidl_fuchsia_mem::Buffer, DynamicDataSinkWriteOpaqueVolumeResponder)> {
        if let DynamicDataSinkRequest::WriteOpaqueVolume { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_write_sparse_volume(
        self,
    ) -> Option<(fidl_fuchsia_mem::Buffer, DynamicDataSinkWriteSparseVolumeResponder)> {
        if let DynamicDataSinkRequest::WriteSparseVolume { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_flush(self) -> Option<(DynamicDataSinkFlushResponder)> {
        if let DynamicDataSinkRequest::Flush { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_initialize_partition_tables(
        self,
    ) -> Option<(DynamicDataSinkInitializePartitionTablesResponder)> {
        if let DynamicDataSinkRequest::InitializePartitionTables { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_wipe_partition_tables(
        self,
    ) -> Option<(DynamicDataSinkWipePartitionTablesResponder)> {
        if let DynamicDataSinkRequest::WipePartitionTables { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            DynamicDataSinkRequest::ReadAsset { .. } => "read_asset",
            DynamicDataSinkRequest::WriteAsset { .. } => "write_asset",
            DynamicDataSinkRequest::WriteFirmware { .. } => "write_firmware",
            DynamicDataSinkRequest::ReadFirmware { .. } => "read_firmware",
            DynamicDataSinkRequest::WriteVolumes { .. } => "write_volumes",
            DynamicDataSinkRequest::WriteOpaqueVolume { .. } => "write_opaque_volume",
            DynamicDataSinkRequest::WriteSparseVolume { .. } => "write_sparse_volume",
            DynamicDataSinkRequest::Flush { .. } => "flush",
            DynamicDataSinkRequest::InitializePartitionTables { .. } => {
                "initialize_partition_tables"
            }
            DynamicDataSinkRequest::WipePartitionTables { .. } => "wipe_partition_tables",
        }
    }
}

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

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

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

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

impl DynamicDataSinkControlHandle {}

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

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

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

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

    fn send_raw(
        &self,
        mut result: Result<fidl_fuchsia_mem::Buffer, i32>,
    ) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<DataSinkReadAssetResponse, i32>>(
                result.as_mut().map_err(|e| *e).map(|asset| (asset,)),
                self.tx_id,
                0x125a23e561007898,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut result: &WriteFirmwareResult) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<DataSinkWriteFirmwareResponse>(
            (result,),
            self.tx_id,
            0x514b93454ac0be97,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

    fn send_raw(
        &self,
        mut result: Result<fidl_fuchsia_mem::Buffer, i32>,
    ) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<DataSinkReadFirmwareResponse, i32>>(
                result.as_mut().map_err(|e| *e).map(|firmware| (firmware,)),
                self.tx_id,
                0xcb67f9830cae9c3,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for PaverMarker {
    type Proxy = PaverProxy;
    type RequestStream = PaverRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = PaverSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.paver.Paver";
}
impl fidl::endpoints::DiscoverableProtocolMarker for PaverMarker {}

pub trait PaverProxyInterface: Send + Sync {
    fn r#find_data_sink(
        &self,
        data_sink: fidl::endpoints::ServerEnd<DataSinkMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#find_partition_table_manager(
        &self,
        data_sink: fidl::endpoints::ServerEnd<DynamicDataSinkMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#find_boot_manager(
        &self,
        boot_manager: fidl::endpoints::ServerEnd<BootManagerMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#find_sysconfig(
        &self,
        sysconfig: fidl::endpoints::ServerEnd<SysconfigMarker>,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct PaverSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for PaverSynchronousProxy {
    type Proxy = PaverProxy;
    type Protocol = PaverMarker;

    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 PaverSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <PaverMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

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

    /// Attempts to auto-discover the data sink where assets and volumes will get paved to.
    /// On devices with GPT, the partition must have a valid FVM partition in order for
    /// auto-discovery to find it. If multiple devices are found suitable, error is returned.
    ///
    /// `data_sink` will be closed on error, with an epitaph provided on failure reason.
    pub fn r#find_data_sink(
        &self,
        mut data_sink: fidl::endpoints::ServerEnd<DataSinkMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PaverFindDataSinkRequest>(
            (data_sink,),
            0x710a34c6f9c8a0e9,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Like `FindDataSink`, but the returned block device will be dynamic, supporting partition
    /// table manipulation.
    ///
    /// `data_sink` will be closed on error, with an epitaph provided on failure reason.
    pub fn r#find_partition_table_manager(
        &self,
        mut data_sink: fidl::endpoints::ServerEnd<DynamicDataSinkMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PaverFindPartitionTableManagerRequest>(
            (data_sink,),
            0x10991ecc6fb9f47b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Attempts to auto-discover the boot manager.
    ///
    /// `boot_manager` will be closed on error, with an epitaph provided on failure reason.
    /// ZX_ERR_NOT_SUPPORTED indicates lack of support and configuration A is always booted from.
    pub fn r#find_boot_manager(
        &self,
        mut boot_manager: fidl::endpoints::ServerEnd<BootManagerMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PaverFindBootManagerRequest>(
            (boot_manager,),
            0x5d500b0633102443,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Find Sysconfig service.
    pub fn r#find_sysconfig(
        &self,
        mut sysconfig: fidl::endpoints::ServerEnd<SysconfigMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PaverFindSysconfigRequest>(
            (sysconfig,),
            0x542cdb5be9b5c02d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for PaverProxy {
    type Protocol = PaverMarker;

    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 PaverProxy {
    /// Create a new Proxy for fuchsia.paver/Paver.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <PaverMarker 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) -> PaverEventStream {
        PaverEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Attempts to auto-discover the data sink where assets and volumes will get paved to.
    /// On devices with GPT, the partition must have a valid FVM partition in order for
    /// auto-discovery to find it. If multiple devices are found suitable, error is returned.
    ///
    /// `data_sink` will be closed on error, with an epitaph provided on failure reason.
    pub fn r#find_data_sink(
        &self,
        mut data_sink: fidl::endpoints::ServerEnd<DataSinkMarker>,
    ) -> Result<(), fidl::Error> {
        PaverProxyInterface::r#find_data_sink(self, data_sink)
    }

    /// Like `FindDataSink`, but the returned block device will be dynamic, supporting partition
    /// table manipulation.
    ///
    /// `data_sink` will be closed on error, with an epitaph provided on failure reason.
    pub fn r#find_partition_table_manager(
        &self,
        mut data_sink: fidl::endpoints::ServerEnd<DynamicDataSinkMarker>,
    ) -> Result<(), fidl::Error> {
        PaverProxyInterface::r#find_partition_table_manager(self, data_sink)
    }

    /// Attempts to auto-discover the boot manager.
    ///
    /// `boot_manager` will be closed on error, with an epitaph provided on failure reason.
    /// ZX_ERR_NOT_SUPPORTED indicates lack of support and configuration A is always booted from.
    pub fn r#find_boot_manager(
        &self,
        mut boot_manager: fidl::endpoints::ServerEnd<BootManagerMarker>,
    ) -> Result<(), fidl::Error> {
        PaverProxyInterface::r#find_boot_manager(self, boot_manager)
    }

    /// Find Sysconfig service.
    pub fn r#find_sysconfig(
        &self,
        mut sysconfig: fidl::endpoints::ServerEnd<SysconfigMarker>,
    ) -> Result<(), fidl::Error> {
        PaverProxyInterface::r#find_sysconfig(self, sysconfig)
    }
}

impl PaverProxyInterface for PaverProxy {
    fn r#find_data_sink(
        &self,
        mut data_sink: fidl::endpoints::ServerEnd<DataSinkMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PaverFindDataSinkRequest>(
            (data_sink,),
            0x710a34c6f9c8a0e9,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#find_partition_table_manager(
        &self,
        mut data_sink: fidl::endpoints::ServerEnd<DynamicDataSinkMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PaverFindPartitionTableManagerRequest>(
            (data_sink,),
            0x10991ecc6fb9f47b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#find_boot_manager(
        &self,
        mut boot_manager: fidl::endpoints::ServerEnd<BootManagerMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PaverFindBootManagerRequest>(
            (boot_manager,),
            0x5d500b0633102443,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#find_sysconfig(
        &self,
        mut sysconfig: fidl::endpoints::ServerEnd<SysconfigMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PaverFindSysconfigRequest>(
            (sysconfig,),
            0x542cdb5be9b5c02d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for PaverRequestStream {
    type Protocol = PaverMarker;
    type ControlHandle = PaverControlHandle;

    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 {
        PaverControlHandle { 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 PaverRequestStream {
    type Item = Result<PaverRequest, 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 PaverRequestStream 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 {
                    0x710a34c6f9c8a0e9 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PaverFindDataSinkRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PaverFindDataSinkRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PaverControlHandle { inner: this.inner.clone() };
                        Ok(PaverRequest::FindDataSink { data_sink: req.data_sink, control_handle })
                    }
                    0x10991ecc6fb9f47b => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PaverFindPartitionTableManagerRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PaverFindPartitionTableManagerRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PaverControlHandle { inner: this.inner.clone() };
                        Ok(PaverRequest::FindPartitionTableManager {
                            data_sink: req.data_sink,

                            control_handle,
                        })
                    }
                    0x5d500b0633102443 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PaverFindBootManagerRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PaverFindBootManagerRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PaverControlHandle { inner: this.inner.clone() };
                        Ok(PaverRequest::FindBootManager {
                            boot_manager: req.boot_manager,

                            control_handle,
                        })
                    }
                    0x542cdb5be9b5c02d => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PaverFindSysconfigRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PaverFindSysconfigRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PaverControlHandle { inner: this.inner.clone() };
                        Ok(PaverRequest::FindSysconfig { sysconfig: req.sysconfig, control_handle })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name: <PaverMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

#[derive(Debug)]
pub enum PaverRequest {
    /// Attempts to auto-discover the data sink where assets and volumes will get paved to.
    /// On devices with GPT, the partition must have a valid FVM partition in order for
    /// auto-discovery to find it. If multiple devices are found suitable, error is returned.
    ///
    /// `data_sink` will be closed on error, with an epitaph provided on failure reason.
    FindDataSink {
        data_sink: fidl::endpoints::ServerEnd<DataSinkMarker>,
        control_handle: PaverControlHandle,
    },
    /// Like `FindDataSink`, but the returned block device will be dynamic, supporting partition
    /// table manipulation.
    ///
    /// `data_sink` will be closed on error, with an epitaph provided on failure reason.
    FindPartitionTableManager {
        data_sink: fidl::endpoints::ServerEnd<DynamicDataSinkMarker>,
        control_handle: PaverControlHandle,
    },
    /// Attempts to auto-discover the boot manager.
    ///
    /// `boot_manager` will be closed on error, with an epitaph provided on failure reason.
    /// ZX_ERR_NOT_SUPPORTED indicates lack of support and configuration A is always booted from.
    FindBootManager {
        boot_manager: fidl::endpoints::ServerEnd<BootManagerMarker>,
        control_handle: PaverControlHandle,
    },
    /// Find Sysconfig service.
    FindSysconfig {
        sysconfig: fidl::endpoints::ServerEnd<SysconfigMarker>,
        control_handle: PaverControlHandle,
    },
}

impl PaverRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_find_data_sink(
        self,
    ) -> Option<(fidl::endpoints::ServerEnd<DataSinkMarker>, PaverControlHandle)> {
        if let PaverRequest::FindDataSink { data_sink, control_handle } = self {
            Some((data_sink, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_find_partition_table_manager(
        self,
    ) -> Option<(fidl::endpoints::ServerEnd<DynamicDataSinkMarker>, PaverControlHandle)> {
        if let PaverRequest::FindPartitionTableManager { data_sink, control_handle } = self {
            Some((data_sink, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_find_boot_manager(
        self,
    ) -> Option<(fidl::endpoints::ServerEnd<BootManagerMarker>, PaverControlHandle)> {
        if let PaverRequest::FindBootManager { boot_manager, control_handle } = self {
            Some((boot_manager, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_find_sysconfig(
        self,
    ) -> Option<(fidl::endpoints::ServerEnd<SysconfigMarker>, PaverControlHandle)> {
        if let PaverRequest::FindSysconfig { sysconfig, control_handle } = self {
            Some((sysconfig, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            PaverRequest::FindDataSink { .. } => "find_data_sink",
            PaverRequest::FindPartitionTableManager { .. } => "find_partition_table_manager",
            PaverRequest::FindBootManager { .. } => "find_boot_manager",
            PaverRequest::FindSysconfig { .. } => "find_sysconfig",
        }
    }
}

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

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

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

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

impl PaverControlHandle {}

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

impl fidl::endpoints::ProtocolMarker for PayloadStreamMarker {
    type Proxy = PayloadStreamProxy;
    type RequestStream = PayloadStreamRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = PayloadStreamSynchronousProxy;

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

pub trait PayloadStreamProxyInterface: Send + Sync {
    type RegisterVmoResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#register_vmo(&self, vmo: fidl::Vmo) -> Self::RegisterVmoResponseFut;
    type ReadDataResponseFut: std::future::Future<Output = Result<ReadResult, fidl::Error>> + Send;
    fn r#read_data(&self) -> Self::ReadDataResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct PayloadStreamSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for PayloadStreamSynchronousProxy {
    type Proxy = PayloadStreamProxy;
    type Protocol = PayloadStreamMarker;

    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 PayloadStreamSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <PayloadStreamMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

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

    /// Registers a VMO to stream into.
    ///
    /// This can be called once per PayloadStream.
    /// Any subsequent calls will return ZX_ERR_ALREADY_BOUND.
    pub fn r#register_vmo(
        &self,
        mut vmo: fidl::Vmo,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<i32, fidl::Error> {
        let _response = self
            .client
            .send_query::<PayloadStreamRegisterVmoRequest, PayloadStreamRegisterVmoResponse>(
                (vmo,),
                0x388d7fe44bcb4c,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.status)
    }

    /// Reads data into the pre-registered vmo.
    pub fn r#read_data(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ReadResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, PayloadStreamReadDataResponse>(
                (),
                0x2ccde55366318afa,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.result)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for PayloadStreamProxy {
    type Protocol = PayloadStreamMarker;

    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 PayloadStreamProxy {
    /// Create a new Proxy for fuchsia.paver/PayloadStream.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <PayloadStreamMarker 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) -> PayloadStreamEventStream {
        PayloadStreamEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Registers a VMO to stream into.
    ///
    /// This can be called once per PayloadStream.
    /// Any subsequent calls will return ZX_ERR_ALREADY_BOUND.
    pub fn r#register_vmo(
        &self,
        mut vmo: fidl::Vmo,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        PayloadStreamProxyInterface::r#register_vmo(self, vmo)
    }

    /// Reads data into the pre-registered vmo.
    pub fn r#read_data(
        &self,
    ) -> fidl::client::QueryResponseFut<ReadResult, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        PayloadStreamProxyInterface::r#read_data(self)
    }
}

impl PayloadStreamProxyInterface for PayloadStreamProxy {
    type RegisterVmoResponseFut =
        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#register_vmo(&self, mut vmo: fidl::Vmo) -> Self::RegisterVmoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                PayloadStreamRegisterVmoResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x388d7fe44bcb4c,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<PayloadStreamRegisterVmoRequest, i32>(
            (vmo,),
            0x388d7fe44bcb4c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for PayloadStreamRequestStream {
    type Protocol = PayloadStreamMarker;
    type ControlHandle = PayloadStreamControlHandle;

    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 {
        PayloadStreamControlHandle { 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 PayloadStreamRequestStream {
    type Item = Result<PayloadStreamRequest, 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 PayloadStreamRequestStream 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 {
                    0x388d7fe44bcb4c => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            PayloadStreamRegisterVmoRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PayloadStreamRegisterVmoRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            PayloadStreamControlHandle { inner: this.inner.clone() };
                        Ok(PayloadStreamRequest::RegisterVmo {
                            vmo: req.vmo,

                            responder: PayloadStreamRegisterVmoResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2ccde55366318afa => {
                        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 =
                            PayloadStreamControlHandle { inner: this.inner.clone() };
                        Ok(PayloadStreamRequest::ReadData {
                            responder: PayloadStreamReadDataResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <PayloadStreamMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Protocol for streaming the FVM payload.
#[derive(Debug)]
pub enum PayloadStreamRequest {
    /// Registers a VMO to stream into.
    ///
    /// This can be called once per PayloadStream.
    /// Any subsequent calls will return ZX_ERR_ALREADY_BOUND.
    RegisterVmo { vmo: fidl::Vmo, responder: PayloadStreamRegisterVmoResponder },
    /// Reads data into the pre-registered vmo.
    ReadData { responder: PayloadStreamReadDataResponder },
}

impl PayloadStreamRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_register_vmo(self) -> Option<(fidl::Vmo, PayloadStreamRegisterVmoResponder)> {
        if let PayloadStreamRequest::RegisterVmo { vmo, responder } = self {
            Some((vmo, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_read_data(self) -> Option<(PayloadStreamReadDataResponder)> {
        if let PayloadStreamRequest::ReadData { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            PayloadStreamRequest::RegisterVmo { .. } => "register_vmo",
            PayloadStreamRequest::ReadData { .. } => "read_data",
        }
    }
}

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

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

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

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

impl PayloadStreamControlHandle {}

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut result: &ReadResult) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<PayloadStreamReadDataResponse>(
            (result,),
            self.tx_id,
            0x2ccde55366318afa,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for SysconfigMarker {
    type Proxy = SysconfigProxy;
    type RequestStream = SysconfigRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = SysconfigSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) Sysconfig";
}
pub type SysconfigReadResult = Result<fidl_fuchsia_mem::Buffer, i32>;
pub type SysconfigGetPartitionSizeResult = Result<u64, i32>;

pub trait SysconfigProxyInterface: Send + Sync {
    type ReadResponseFut: std::future::Future<Output = Result<SysconfigReadResult, fidl::Error>>
        + Send;
    fn r#read(&self) -> Self::ReadResponseFut;
    type WriteResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#write(&self, payload: fidl_fuchsia_mem::Buffer) -> Self::WriteResponseFut;
    type GetPartitionSizeResponseFut: std::future::Future<Output = Result<SysconfigGetPartitionSizeResult, fidl::Error>>
        + Send;
    fn r#get_partition_size(&self) -> Self::GetPartitionSizeResponseFut;
    type FlushResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#flush(&self) -> Self::FlushResponseFut;
    type WipeResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#wipe(&self) -> Self::WipeResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct SysconfigSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for SysconfigSynchronousProxy {
    type Proxy = SysconfigProxy;
    type Protocol = SysconfigMarker;

    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 SysconfigSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <SysconfigMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

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

    /// Read from the sub-partition
    pub fn r#read(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SysconfigReadResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<SysconfigReadResponse, i32>,
        >(
            (),
            0x350c317c53c226fc,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.data))
    }

    /// Writes to the sub-partition
    pub fn r#write(
        &self,
        mut payload: fidl_fuchsia_mem::Buffer,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<i32, fidl::Error> {
        let _response = self.client.send_query::<SysconfigWriteRequest, SysconfigWriteResponse>(
            (&mut payload,),
            0x393786c114caf171,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.status)
    }

    /// Get sub-partition size.
    pub fn r#get_partition_size(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SysconfigGetPartitionSizeResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<SysconfigGetPartitionSizeResponse, i32>,
        >(
            (),
            0x2570c58b74fb8957,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.size))
    }

    /// Flush all previously buffered data to persistent storage.
    pub fn r#flush(&self, ___deadline: zx::MonotonicInstant) -> Result<i32, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, SysconfigFlushResponse>(
                (),
                0xc6c1bb233d003c6,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.status)
    }

    /// Wipe all data in the sub-partition (write 0 to all bytes).
    pub fn r#wipe(&self, ___deadline: zx::MonotonicInstant) -> Result<i32, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, SysconfigWipeResponse>(
                (),
                0x34a634965ebfb702,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.status)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for SysconfigProxy {
    type Protocol = SysconfigMarker;

    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 SysconfigProxy {
    /// Create a new Proxy for fuchsia.paver/Sysconfig.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <SysconfigMarker 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) -> SysconfigEventStream {
        SysconfigEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Read from the sub-partition
    pub fn r#read(
        &self,
    ) -> fidl::client::QueryResponseFut<
        SysconfigReadResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SysconfigProxyInterface::r#read(self)
    }

    /// Writes to the sub-partition
    pub fn r#write(
        &self,
        mut payload: fidl_fuchsia_mem::Buffer,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        SysconfigProxyInterface::r#write(self, payload)
    }

    /// Get sub-partition size.
    pub fn r#get_partition_size(
        &self,
    ) -> fidl::client::QueryResponseFut<
        SysconfigGetPartitionSizeResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SysconfigProxyInterface::r#get_partition_size(self)
    }

    /// Flush all previously buffered data to persistent storage.
    pub fn r#flush(
        &self,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        SysconfigProxyInterface::r#flush(self)
    }

    /// Wipe all data in the sub-partition (write 0 to all bytes).
    pub fn r#wipe(
        &self,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        SysconfigProxyInterface::r#wipe(self)
    }
}

impl SysconfigProxyInterface for SysconfigProxy {
    type ReadResponseFut = fidl::client::QueryResponseFut<
        SysconfigReadResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#read(&self) -> Self::ReadResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SysconfigReadResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<SysconfigReadResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x350c317c53c226fc,
            >(_buf?)?;
            Ok(_response.map(|x| x.data))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, SysconfigReadResult>(
            (),
            0x350c317c53c226fc,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type WriteResponseFut =
        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#write(&self, mut payload: fidl_fuchsia_mem::Buffer) -> Self::WriteResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                SysconfigWriteResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x393786c114caf171,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<SysconfigWriteRequest, i32>(
            (&mut payload,),
            0x393786c114caf171,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

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

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for SysconfigRequestStream {
    type Protocol = SysconfigMarker;
    type ControlHandle = SysconfigControlHandle;

    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 {
        SysconfigControlHandle { 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 SysconfigRequestStream {
    type Item = Result<SysconfigRequest, 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 SysconfigRequestStream 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 {
                    0x350c317c53c226fc => {
                        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 = SysconfigControlHandle { inner: this.inner.clone() };
                        Ok(SysconfigRequest::Read {
                            responder: SysconfigReadResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x393786c114caf171 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SysconfigWriteRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SysconfigWriteRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SysconfigControlHandle { inner: this.inner.clone() };
                        Ok(SysconfigRequest::Write {
                            payload: req.payload,

                            responder: SysconfigWriteResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2570c58b74fb8957 => {
                        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 = SysconfigControlHandle { inner: this.inner.clone() };
                        Ok(SysconfigRequest::GetPartitionSize {
                            responder: SysconfigGetPartitionSizeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0xc6c1bb233d003c6 => {
                        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 = SysconfigControlHandle { inner: this.inner.clone() };
                        Ok(SysconfigRequest::Flush {
                            responder: SysconfigFlushResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x34a634965ebfb702 => {
                        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 = SysconfigControlHandle { inner: this.inner.clone() };
                        Ok(SysconfigRequest::Wipe {
                            responder: SysconfigWipeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <SysconfigMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Protocol that provides access to sysconfig-data sub-partition in sysconfig partition.
/// The main user of the protocol are pkg-solver and system update-checker, which need to
/// read/write sysconfig-data channel.
#[derive(Debug)]
pub enum SysconfigRequest {
    /// Read from the sub-partition
    Read { responder: SysconfigReadResponder },
    /// Writes to the sub-partition
    Write { payload: fidl_fuchsia_mem::Buffer, responder: SysconfigWriteResponder },
    /// Get sub-partition size.
    GetPartitionSize { responder: SysconfigGetPartitionSizeResponder },
    /// Flush all previously buffered data to persistent storage.
    Flush { responder: SysconfigFlushResponder },
    /// Wipe all data in the sub-partition (write 0 to all bytes).
    Wipe { responder: SysconfigWipeResponder },
}

impl SysconfigRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_read(self) -> Option<(SysconfigReadResponder)> {
        if let SysconfigRequest::Read { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_write(self) -> Option<(fidl_fuchsia_mem::Buffer, SysconfigWriteResponder)> {
        if let SysconfigRequest::Write { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_partition_size(self) -> Option<(SysconfigGetPartitionSizeResponder)> {
        if let SysconfigRequest::GetPartitionSize { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_flush(self) -> Option<(SysconfigFlushResponder)> {
        if let SysconfigRequest::Flush { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_wipe(self) -> Option<(SysconfigWipeResponder)> {
        if let SysconfigRequest::Wipe { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            SysconfigRequest::Read { .. } => "read",
            SysconfigRequest::Write { .. } => "write",
            SysconfigRequest::GetPartitionSize { .. } => "get_partition_size",
            SysconfigRequest::Flush { .. } => "flush",
            SysconfigRequest::Wipe { .. } => "wipe",
        }
    }
}

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

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

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

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

impl SysconfigControlHandle {}

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

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

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

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

    fn send_raw(
        &self,
        mut result: Result<fidl_fuchsia_mem::Buffer, i32>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<SysconfigReadResponse, i32>>(
            result.as_mut().map_err(|e| *e).map(|data| (data,)),
            self.tx_id,
            0x350c317c53c226fc,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

mod internal {
    use super::*;

    impl fidl::encoding::ResourceTypeMarker for DataSinkReadFirmwareRequest {
        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 DataSinkReadFirmwareRequest {
        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<
            DataSinkReadFirmwareRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut DataSinkReadFirmwareRequest
    {
        #[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::<DataSinkReadFirmwareRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                DataSinkReadFirmwareRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <Configuration as fidl::encoding::ValueTypeMarker>::borrow(&self.configuration),
                    <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.type_,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<Configuration, fidl::encoding::DefaultFuchsiaResourceDialect>,
            T1: fidl::encoding::Encode<
                fidl::encoding::BoundedString<256>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            DataSinkReadFirmwareRequest,
            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::<DataSinkReadFirmwareRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for DataSinkReadFirmwareRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                configuration: fidl::new_empty!(
                    Configuration,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                type_: fidl::new_empty!(
                    fidl::encoding::BoundedString<256>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for DataSinkWriteAssetRequest {
        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 DataSinkWriteAssetRequest {
        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<
            DataSinkWriteAssetRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut DataSinkWriteAssetRequest
    {
        #[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::<DataSinkWriteAssetRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DataSinkWriteAssetRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <Configuration as fidl::encoding::ValueTypeMarker>::borrow(&self.configuration),
                    <Asset as fidl::encoding::ValueTypeMarker>::borrow(&self.asset),
                    <fidl_fuchsia_mem::Buffer as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.payload),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<Configuration, fidl::encoding::DefaultFuchsiaResourceDialect>,
            T1: fidl::encoding::Encode<Asset, fidl::encoding::DefaultFuchsiaResourceDialect>,
            T2: fidl::encoding::Encode<
                fidl_fuchsia_mem::Buffer,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            DataSinkWriteAssetRequest,
            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::<DataSinkWriteAssetRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            self.2.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for DataSinkWriteAssetRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                configuration: fidl::new_empty!(
                    Configuration,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                asset: fidl::new_empty!(Asset, fidl::encoding::DefaultFuchsiaResourceDialect),
                payload: fidl::new_empty!(
                    fidl_fuchsia_mem::Buffer,
                    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!(
                Configuration,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.configuration,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                Asset,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.asset,
                decoder,
                offset + 4,
                _depth
            )?;
            fidl::decode!(
                fidl_fuchsia_mem::Buffer,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.payload,
                decoder,
                offset + 8,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for DataSinkWriteFirmwareRequest {
        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 DataSinkWriteFirmwareRequest {
        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<
            DataSinkWriteFirmwareRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut DataSinkWriteFirmwareRequest
    {
        #[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::<DataSinkWriteFirmwareRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DataSinkWriteFirmwareRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <Configuration as fidl::encoding::ValueTypeMarker>::borrow(&self.configuration),
                    <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow(&self.type_),
                    <fidl_fuchsia_mem::Buffer as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.payload),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<Configuration, fidl::encoding::DefaultFuchsiaResourceDialect>,
            T1: fidl::encoding::Encode<
                fidl::encoding::BoundedString<256>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T2: fidl::encoding::Encode<
                fidl_fuchsia_mem::Buffer,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            DataSinkWriteFirmwareRequest,
            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::<DataSinkWriteFirmwareRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            self.2.encode(encoder, offset + 24, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for DataSinkWriteFirmwareRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                configuration: fidl::new_empty!(
                    Configuration,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                type_: fidl::new_empty!(
                    fidl::encoding::BoundedString<256>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                payload: fidl::new_empty!(
                    fidl_fuchsia_mem::Buffer,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                Configuration,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.configuration,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::BoundedString<256>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.type_,
                decoder,
                offset + 8,
                _depth
            )?;
            fidl::decode!(
                fidl_fuchsia_mem::Buffer,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.payload,
                decoder,
                offset + 24,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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