fdomain_fuchsia_fuzzer/

fdomain_fuchsia_fuzzer.rs

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

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

use bitflags::bitflags;
use fdomain_client::fidl::{ControlHandle as _, FDomainFlexibleIntoResult as _, Responder as _};
use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
pub use fidl_fuchsia_fuzzer_common::*;
use futures::future::{self, MaybeDone, TryFutureExt};
use zx_status;

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ControllerAddMonitorRequest {
    pub monitor: fdomain_client::fidl::ClientEnd<MonitorMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ControllerAddToCorpusRequest {
    pub corpus: Corpus,
    pub input: Input,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ControllerCleanseRequest {
    pub test_input: Input,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ControllerMinimizeRequest {
    pub test_input: Input,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ControllerProviderConnectRequest {
    pub controller: fdomain_client::fidl::ServerEnd<ControllerMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ControllerReadCorpusRequest {
    pub corpus: Corpus,
    pub corpus_reader: fdomain_client::fidl::ClientEnd<CorpusReaderMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ControllerReadDictionaryResponse {
    pub dictionary: Input,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ControllerTryOneRequest {
    pub test_input: Input,
}

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

#[derive(Debug, PartialEq)]
pub struct ControllerWatchArtifactResponse {
    pub artifact: Artifact,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ControllerWriteDictionaryRequest {
    pub dictionary: Input,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct CorpusReaderNextRequest {
    pub test_input: Input,
}

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

/// Represents an instrumented target process or the code coverage it is sharing.
#[derive(Debug, PartialEq)]
pub struct CoverageData {
    pub target_id: u64,
    pub data: Data,
}

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

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

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct CoverageDataCollectorInitializeRequest {
    pub eventpair: fdomain_client::EventPair,
    pub process: fdomain_client::Process,
}

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

#[derive(Debug, PartialEq)]
pub struct CoverageDataProviderWatchCoverageDataResponse {
    pub coverage_data: Vec<CoverageData>,
}

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

/// Encapsulation of a fuzzer input transferred over a socket, e.g. between a
/// host and device via overnet.
#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct Input {
    /// Socket that can be used to read the data.
    pub socket: fdomain_client::Socket,
    /// The total amount of data to be transferred.
    pub size: u64,
}

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

/// Represents an instrumented target process under test.
///
/// This struct wraps the eventpair and process provided to `CoverageDataCollector.Initialize` and
/// associates it with a unique per-`CoverageDataCollector`-client target id.
#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct InstrumentedProcess {
    pub eventpair: fdomain_client::EventPair,
    pub process: fdomain_client::Process,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ManagerConnectRequest {
    pub fuzzer_url: String,
    pub controller: fdomain_client::fidl::ServerEnd<ControllerMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ManagerGetOutputRequest {
    pub fuzzer_url: String,
    pub output: TestOutput,
    pub socket: fdomain_client::Socket,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RegistrarRegisterRequest {
    pub fuzzer_url: String,
    pub provider: fdomain_client::fidl::ClientEnd<ControllerProviderMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RegistryConnectRequest {
    pub fuzzer_url: String,
    pub controller: fdomain_client::fidl::ServerEnd<ControllerMarker>,
    pub timeout: i64,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TargetAdapterConnectRequest {
    pub eventpair: fdomain_client::EventPair,
    pub test_input: fdomain_client::Vmo,
}

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

/// Encapsulates the result of a long-running fuzzing workflow and optionally
/// the input that caused it, depending on the workflow.
#[derive(Debug, Default, PartialEq)]
pub struct Artifact {
    /// Result of executing the long-running workflow.
    pub result: Option<Result_>,
    /// Optional fuzzer input produced by a specific long-running workflow. This
    /// may be:
    ///
    /// * A discovered input in the case of `Fuzz`
    /// * A constructed input in the cases of `Cleanse` and `Minimize`.
    /// * Omitted in the cases of `TryOne` and `Merge`.
    pub input: Option<Input>,
    /// An error generated during a long-running workflow. These errors are
    /// distinct from those that result from validating workflow requests and
    /// are documented for the workflow methods below. These errors result from
    /// unexpected framework failure. For example, if libFuzzer fails due to an
    /// internal error, the engine will report it via this field.
    ///
    /// The `result` and `input` fields are invalid if this field is present and
    /// anything other than `ZX_OK`.
    pub error: Option<i32>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug)]
pub enum Data {
    /// An instrumented target process under test.
    Instrumented(InstrumentedProcess),
    /// See https://clang.llvm.org/docs/SanitizerCoverage.html#inline-8bit-counters
    Inline8bitCounters(fdomain_client::Vmo),
    #[doc(hidden)]
    __SourceBreaking { unknown_ordinal: u64 },
}

/// Pattern that matches an unknown `Data` member.
#[macro_export]
macro_rules! DataUnknown {
    () => {
        _
    };
}

// Custom PartialEq so that unknown variants are not equal to themselves.
impl PartialEq for Data {
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (Self::Instrumented(x), Self::Instrumented(y)) => *x == *y,
            (Self::Inline8bitCounters(x), Self::Inline8bitCounters(y)) => *x == *y,
            _ => false,
        }
    }
}

impl Data {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::Instrumented(_) => 1,
            Self::Inline8bitCounters(_) => 2,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

    #[inline]
    pub fn unknown_variant_for_testing() -> Self {
        Self::__SourceBreaking { unknown_ordinal: 0 }
    }

    #[inline]
    pub fn is_unknown(&self) -> bool {
        match self {
            Self::__SourceBreaking { .. } => true,
            _ => false,
        }
    }
}

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

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

impl fdomain_client::fidl::ProtocolMarker for ControllerMarker {
    type Proxy = ControllerProxy;
    type RequestStream = ControllerRequestStream;

    const DEBUG_NAME: &'static str = "(anonymous) Controller";
}
pub type ControllerConfigureResult = Result<(), i32>;
pub type ControllerAddToCorpusResult = Result<(), i32>;
pub type ControllerWriteDictionaryResult = Result<(), i32>;
pub type ControllerFuzzResult = Result<(), i32>;
pub type ControllerTryOneResult = Result<(), i32>;
pub type ControllerMinimizeResult = Result<(), i32>;
pub type ControllerCleanseResult = Result<(), i32>;
pub type ControllerMergeResult = Result<(), i32>;

pub trait ControllerProxyInterface: Send + Sync {
    type ConfigureResponseFut: std::future::Future<Output = Result<ControllerConfigureResult, fidl::Error>>
        + Send;
    fn r#configure(&self, options: &Options) -> Self::ConfigureResponseFut;
    type GetOptionsResponseFut: std::future::Future<Output = Result<Options, fidl::Error>> + Send;
    fn r#get_options(&self) -> Self::GetOptionsResponseFut;
    type AddToCorpusResponseFut: std::future::Future<Output = Result<ControllerAddToCorpusResult, fidl::Error>>
        + Send;
    fn r#add_to_corpus(&self, corpus: Corpus, input: Input) -> Self::AddToCorpusResponseFut;
    type ReadCorpusResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#read_corpus(
        &self,
        corpus: Corpus,
        corpus_reader: fdomain_client::fidl::ClientEnd<CorpusReaderMarker>,
    ) -> Self::ReadCorpusResponseFut;
    type WriteDictionaryResponseFut: std::future::Future<Output = Result<ControllerWriteDictionaryResult, fidl::Error>>
        + Send;
    fn r#write_dictionary(&self, dictionary: Input) -> Self::WriteDictionaryResponseFut;
    type ReadDictionaryResponseFut: std::future::Future<Output = Result<Input, fidl::Error>> + Send;
    fn r#read_dictionary(&self) -> Self::ReadDictionaryResponseFut;
    type AddMonitorResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#add_monitor(
        &self,
        monitor: fdomain_client::fidl::ClientEnd<MonitorMarker>,
    ) -> Self::AddMonitorResponseFut;
    type FuzzResponseFut: std::future::Future<Output = Result<ControllerFuzzResult, fidl::Error>>
        + Send;
    fn r#fuzz(&self) -> Self::FuzzResponseFut;
    type TryOneResponseFut: std::future::Future<Output = Result<ControllerTryOneResult, fidl::Error>>
        + Send;
    fn r#try_one(&self, test_input: Input) -> Self::TryOneResponseFut;
    type MinimizeResponseFut: std::future::Future<Output = Result<ControllerMinimizeResult, fidl::Error>>
        + Send;
    fn r#minimize(&self, test_input: Input) -> Self::MinimizeResponseFut;
    type CleanseResponseFut: std::future::Future<Output = Result<ControllerCleanseResult, fidl::Error>>
        + Send;
    fn r#cleanse(&self, test_input: Input) -> Self::CleanseResponseFut;
    type MergeResponseFut: std::future::Future<Output = Result<ControllerMergeResult, fidl::Error>>
        + Send;
    fn r#merge(&self) -> Self::MergeResponseFut;
    type GetStatusResponseFut: std::future::Future<Output = Result<Status, fidl::Error>> + Send;
    fn r#get_status(&self) -> Self::GetStatusResponseFut;
    type WatchArtifactResponseFut: std::future::Future<Output = Result<Artifact, fidl::Error>>
        + Send;
    fn r#watch_artifact(&self) -> Self::WatchArtifactResponseFut;
}

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

impl fdomain_client::fidl::Proxy for ControllerProxy {
    type Protocol = ControllerMarker;

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

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

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

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

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

    /// Sets various execution and error detection parameters. This may be
    /// called multiple times; only the most recently received options are used.
    /// If the `Options` parameter omits one or more fields, those parameters
    /// are unchanged in the fuzzer. Until the initial call to this method, the
    /// fuzzer should assume the default values for `Options`.
    ///
    /// + request `options` the execution and error detection parameters.
    /// * error one of the following:
    /// * error
    ///     * `ZX_ERR_BAD_STATE` if a long-running call such as `Execute`,
    ///       `Cleanse`, `Minimize`, `Fuzz`, or `Merge` is in progress.
    ///     * `ZX_ERR_NOT_SUPPORTED` if a value provided for an option is not
    ///       supported by the engine. Check the logs for additional details.
    pub fn r#configure(
        &self,
        mut options: &Options,
    ) -> fidl::client::QueryResponseFut<
        ControllerConfigureResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        ControllerProxyInterface::r#configure(self, options)
    }

    /// Gets the current values for the various execution and error detection
    /// parameters.
    ///
    /// - response `options` the execution and error detection parameters.
    pub fn r#get_options(
        &self,
    ) -> fidl::client::QueryResponseFut<Options, fdomain_client::fidl::FDomainResourceDialect> {
        ControllerProxyInterface::r#get_options(self)
    }

    /// Writes the provided `input` to either the "seed" or "live" `corpus`.
    /// Returns an error if transferring the input fails; see `Input` for
    /// details.
    ///
    /// + request `corpus` the type of corpus to add to.
    /// + request `input` the sequence of bytes to add as a test input.
    /// * error one of the following:
    ///     * `ZX_ERR_INVALID_ARGS` if corpus type is invalid.
    ///     * A socket error if transferring the input fails.
    pub fn r#add_to_corpus(
        &self,
        mut corpus: Corpus,
        mut input: Input,
    ) -> fidl::client::QueryResponseFut<
        ControllerAddToCorpusResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        ControllerProxyInterface::r#add_to_corpus(self, corpus, input)
    }

    /// Connects a `corpus_reader` for either the "seed" or "live" corpus.
    ///
    /// + request `corpus` the type of corpus to read from.
    /// + request `corpus_reader` the client used to send test inputs.
    pub fn r#read_corpus(
        &self,
        mut corpus: Corpus,
        mut corpus_reader: fdomain_client::fidl::ClientEnd<CorpusReaderMarker>,
    ) -> fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect> {
        ControllerProxyInterface::r#read_corpus(self, corpus, corpus_reader)
    }

    /// Parses and loads an AFL-style dictionary. Invalid entries are logged and
    /// skipped.
    ///
    /// See also:
    ///
    /// * https://github.com/mirrorer/afl/blob/master/dictionaries/README.dictionaries
    ///
    /// + request `dictionary` the AFL-style dictionary
    /// * error one of the following:
    ///     * A socket error if transferring the input fails.
    ///     *`ZX_ERR_INVALID_ARGS` if parsing the dictionary fails.
    pub fn r#write_dictionary(
        &self,
        mut dictionary: Input,
    ) -> fidl::client::QueryResponseFut<
        ControllerWriteDictionaryResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        ControllerProxyInterface::r#write_dictionary(self, dictionary)
    }

    /// Returns the current dictionary as an Input, which may be empty.
    ///
    /// - response `dictionary` the current AFL-style dictionary.
    pub fn r#read_dictionary(
        &self,
    ) -> fidl::client::QueryResponseFut<Input, fdomain_client::fidl::FDomainResourceDialect> {
        ControllerProxyInterface::r#read_dictionary(self)
    }

    /// Installs a `Monitor` to push status. To pull status instead, use
    /// `GetStatus`.
    ///
    /// + request `monitor` the client used to send status updates.
    pub fn r#add_monitor(
        &self,
        mut monitor: fdomain_client::fidl::ClientEnd<MonitorMarker>,
    ) -> fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect> {
        ControllerProxyInterface::r#add_monitor(self, monitor)
    }

    /// Runs the normal fuzzing feedback loop:
    ///
    /// 1. Selects an input from the corpus.
    /// 2. Mutates the input.
    /// 3. Uses the `TargetAdapter` to execute the input.
    /// 4. Checks feedback from the `InstrumentedProcesses`.
    /// 5. If the input produced useful feedback, adds it to the corpus.
    ///
    /// This call returns quickly, but the loop continues until one of three
    /// conditions is met:
    ///
    /// 1. The configured, non-zero number of `runs` has been reached.
    /// 2. The configured, non-zero `duration` elapses.
    /// 3. An error is detected, and returned.
    ///
    /// See `Result` for more details on long running workflows such as this
    /// one.
    ///
    /// * error `ZX_ERR_BAD_STATE` if another long-running workflow is in
    ///   progress.
    pub fn r#fuzz(
        &self,
    ) -> fidl::client::QueryResponseFut<
        ControllerFuzzResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        ControllerProxyInterface::r#fuzz(self)
    }

    /// Executes the target code with a single `test_input`.
    ///
    /// See `Result` for more details on long running workflows such as this
    /// one.
    ///
    /// + request `input` the sequence of bytes to use with the fuzz target.
    /// * error one of the following:
    ///     * `ZX_ERR_BAD_STATE` if another long-running workflow is in
    ///       progress.
    ///     *  A socket error if transferring the input fails.
    pub fn r#try_one(
        &self,
        mut test_input: Input,
    ) -> fidl::client::QueryResponseFut<
        ControllerTryOneResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        ControllerProxyInterface::r#try_one(self, test_input)
    }

    /// Attempts to find the smallest input that produces the same error as the
    /// given `test_input`,
    /// constrained by the configured `total_time` and/or `runs` options.
    ///
    /// See `Result` for more details on long running workflows such as this
    /// one.
    ///
    /// + request `input` the sequence of bytes to minimize.
    /// * error one of the following:
    ///     * `ZX_ERR_BAD_STATE` if another long-running workflow is in
    ///       progress.
    ///     * A socket error if transferring the input fails.
    ///     * `ZX_ERR_INVALID_ARGS` if the provided `test_input` does not cause
    ///       an error.
    pub fn r#minimize(
        &self,
        mut test_input: Input,
    ) -> fidl::client::QueryResponseFut<
        ControllerMinimizeResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        ControllerProxyInterface::r#minimize(self, test_input)
    }

    /// Attempts to replace bytes of the given `test_input` with "filler" bytes,
    /// e.g. \x00, \xFF, without changing the error produced.
    ///
    /// See `Result` for more details on long running workflows such as this
    /// one.
    ///
    /// To preserve backwards compatibility with libFuzzer and ClusterFuzz, an
    /// input that produces no result is *not* considered an error, and is
    /// returned as-is.
    ///
    /// + request `input` the sequence of bytes to cleanse.
    /// * error one of the following:
    ///     * `ZX_ERR_BAD_STATE` if another long-running workflow is in
    ///       progress.
    ///     * A socket error if transferring the input fails.
    pub fn r#cleanse(
        &self,
        mut test_input: Input,
    ) -> fidl::client::QueryResponseFut<
        ControllerCleanseResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        ControllerProxyInterface::r#cleanse(self, test_input)
    }

    /// Attempts to shrink the corpora. Inputs from the seed corpus will be
    /// preserved. All other inputs will be sorted by amount of feedback
    /// produced and input size, and only those inputs that add new feedback not
    /// seen earlier in the sequence will be kept.
    ///
    /// See `Result` for more details on long running workflows such as this
    /// one.
    ///
    /// * error one of the following:
    ///     * `ZX_ERR_BAD_STATE` if another long-running workflow is in
    ///       progress.
    ///     * `ZX_ERR_INVALID_ARGS` if an input in the seed corpus causes an
    ///       error. Inputs in the live corpus that cause errors are skipped.
    pub fn r#merge(
        &self,
    ) -> fidl::client::QueryResponseFut<
        ControllerMergeResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        ControllerProxyInterface::r#merge(self)
    }

    /// Returns various fuzzing metrics, e.g. total coverage, speed, etc.
    ///
    /// - response `status` the current value of fuzzing metrics.
    pub fn r#get_status(
        &self,
    ) -> fidl::client::QueryResponseFut<Status, fdomain_client::fidl::FDomainResourceDialect> {
        ControllerProxyInterface::r#get_status(self)
    }

    /// Returns the results of a long-running workflow.
    ///
    /// This method uses the
    /// ["hanging get" pattern](https://fuchsia.dev/fuchsia-src/development/api/fidl#hanging-get).
    /// Upon the first call for a given connection, it will immediately return
    /// the controller's current artifact. Upon subsequent calls, it will block
    /// until the controller's artifact changes before returning. Clients should
    /// use `GetStatus` to ensure the fuzzer is not idle before making a
    /// blocking call to `WatchArtifact`.
    ///
    /// Combined with the `Status.running` value obtained from `GetStatus`, this
    /// allows a (re-)connecting client to infer the state of the fuzzer:
    ///
    /// * If the fuzzer is idle and has an empty artifact, then it is
    ///   unchanged since the last connection, if any.
    /// * If the fuzzer is running and has an empty artifact, then it is
    ///   performing a long-running workflow started by a previous connection.
    ///   The client may call `WatchArtifact` again to wait for the workflow
    ///   to complete.
    /// * If the fuzzer is idle and has a non-empty artifact, then it has
    ///   completed a long-running workflow since the last connection.
    ///
    /// It is not an error for clients to disconnect while waiting for a
    /// response from this method. This method is intended to allow clients to
    /// resume waiting for a long-running workflow to complete after
    /// intentionally or inadvertently being disconnected for an indefinite
    /// amount of time.
    ///
    /// - response `artifact` the most recent result and/or error-causing input.
    pub fn r#watch_artifact(
        &self,
    ) -> fidl::client::QueryResponseFut<Artifact, fdomain_client::fidl::FDomainResourceDialect>
    {
        ControllerProxyInterface::r#watch_artifact(self)
    }
}

impl ControllerProxyInterface for ControllerProxy {
    type ConfigureResponseFut = fidl::client::QueryResponseFut<
        ControllerConfigureResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#configure(&self, mut options: &Options) -> Self::ConfigureResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ControllerConfigureResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x35c8cba7fa3d32e4,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<ControllerConfigureRequest, ControllerConfigureResult>(
            (options,),
            0x35c8cba7fa3d32e4,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetOptionsResponseFut =
        fidl::client::QueryResponseFut<Options, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#get_options(&self) -> Self::GetOptionsResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Options, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ControllerGetOptionsResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x683d93332504b9cd,
            >(_buf?)?;
            Ok(_response.options)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Options>(
            (),
            0x683d93332504b9cd,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type AddToCorpusResponseFut = fidl::client::QueryResponseFut<
        ControllerAddToCorpusResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#add_to_corpus(
        &self,
        mut corpus: Corpus,
        mut input: Input,
    ) -> Self::AddToCorpusResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ControllerAddToCorpusResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x7bdf8336ab534cee,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<ControllerAddToCorpusRequest, ControllerAddToCorpusResult>(
                (corpus, &mut input),
                0x7bdf8336ab534cee,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type ReadCorpusResponseFut =
        fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect>;
    fn r#read_corpus(
        &self,
        mut corpus: Corpus,
        mut corpus_reader: fdomain_client::fidl::ClientEnd<CorpusReaderMarker>,
    ) -> Self::ReadCorpusResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fdomain_client::fidl::FDomainResourceDialect,
                0x501279b430b34514,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<ControllerReadCorpusRequest, ()>(
            (corpus, corpus_reader),
            0x501279b430b34514,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

    type ReadDictionaryResponseFut =
        fidl::client::QueryResponseFut<Input, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#read_dictionary(&self) -> Self::ReadDictionaryResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Input, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ControllerReadDictionaryResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x1be6724c87b51c37,
            >(_buf?)?;
            Ok(_response.dictionary)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Input>(
            (),
            0x1be6724c87b51c37,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type AddMonitorResponseFut =
        fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect>;
    fn r#add_monitor(
        &self,
        mut monitor: fdomain_client::fidl::ClientEnd<MonitorMarker>,
    ) -> Self::AddMonitorResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fdomain_client::fidl::FDomainResourceDialect,
                0x2efbf7d3dc21438e,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<ControllerAddMonitorRequest, ()>(
            (monitor,),
            0x2efbf7d3dc21438e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

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

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

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

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

    type GetStatusResponseFut =
        fidl::client::QueryResponseFut<Status, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#get_status(&self) -> Self::GetStatusResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Status, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ControllerGetStatusResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x51db4975d93ce768,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Status>(
            (),
            0x51db4975d93ce768,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type WatchArtifactResponseFut =
        fidl::client::QueryResponseFut<Artifact, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#watch_artifact(&self) -> Self::WatchArtifactResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Artifact, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ControllerWatchArtifactResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x6cfca3730944a414,
            >(_buf?)?;
            Ok(_response.artifact)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Artifact>(
            (),
            0x6cfca3730944a414,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for ControllerRequestStream {
    type Protocol = ControllerMarker;
    type ControlHandle = ControllerControlHandle;

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x35c8cba7fa3d32e4 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ControllerConfigureRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<ControllerConfigureRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ControllerControlHandle { inner: this.inner.clone() };
                        Ok(ControllerRequest::Configure {
                            options: req.options,

                            responder: ControllerConfigureResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x683d93332504b9cd => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ControllerControlHandle { inner: this.inner.clone() };
                        Ok(ControllerRequest::GetOptions {
                            responder: ControllerGetOptionsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7bdf8336ab534cee => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ControllerAddToCorpusRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<ControllerAddToCorpusRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ControllerControlHandle { inner: this.inner.clone() };
                        Ok(ControllerRequest::AddToCorpus {
                            corpus: req.corpus,
                            input: req.input,

                            responder: ControllerAddToCorpusResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x501279b430b34514 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ControllerReadCorpusRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<ControllerReadCorpusRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ControllerControlHandle { inner: this.inner.clone() };
                        Ok(ControllerRequest::ReadCorpus {
                            corpus: req.corpus,
                            corpus_reader: req.corpus_reader,

                            responder: ControllerReadCorpusResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4ecfc1274fe4a70b => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ControllerWriteDictionaryRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<ControllerWriteDictionaryRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ControllerControlHandle { inner: this.inner.clone() };
                        Ok(ControllerRequest::WriteDictionary {
                            dictionary: req.dictionary,

                            responder: ControllerWriteDictionaryResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1be6724c87b51c37 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ControllerControlHandle { inner: this.inner.clone() };
                        Ok(ControllerRequest::ReadDictionary {
                            responder: ControllerReadDictionaryResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2efbf7d3dc21438e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ControllerAddMonitorRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<ControllerAddMonitorRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ControllerControlHandle { inner: this.inner.clone() };
                        Ok(ControllerRequest::AddMonitor {
                            monitor: req.monitor,

                            responder: ControllerAddMonitorResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x62fe3684ea23af62 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ControllerControlHandle { inner: this.inner.clone() };
                        Ok(ControllerRequest::Fuzz {
                            responder: ControllerFuzzResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x368dc762d8e16d46 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ControllerTryOneRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<ControllerTryOneRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ControllerControlHandle { inner: this.inner.clone() };
                        Ok(ControllerRequest::TryOne {
                            test_input: req.test_input,

                            responder: ControllerTryOneResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x105a242ee0552794 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ControllerMinimizeRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<ControllerMinimizeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ControllerControlHandle { inner: this.inner.clone() };
                        Ok(ControllerRequest::Minimize {
                            test_input: req.test_input,

                            responder: ControllerMinimizeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6d7892f62735f3e0 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ControllerCleanseRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<ControllerCleanseRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ControllerControlHandle { inner: this.inner.clone() };
                        Ok(ControllerRequest::Cleanse {
                            test_input: req.test_input,

                            responder: ControllerCleanseResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3614e5c39413b5eb => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ControllerControlHandle { inner: this.inner.clone() };
                        Ok(ControllerRequest::Merge {
                            responder: ControllerMergeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x51db4975d93ce768 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ControllerControlHandle { inner: this.inner.clone() };
                        Ok(ControllerRequest::GetStatus {
                            responder: ControllerGetStatusResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6cfca3730944a414 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ControllerControlHandle { inner: this.inner.clone() };
                        Ok(ControllerRequest::WatchArtifact {
                            responder: ControllerWatchArtifactResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <ControllerMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Provides the management interface for fuzzing.
///
/// This protocol is implemented by the fuzzing engine. Clients for this
/// protocol are provided by `fuchsia.fuzzer/ControllerProvider.Connect`.
///
/// The channel is closed when the fuzzer is no longer needed, and on error.
/// Clients should exit and not attempt to reconnect.
#[derive(Debug)]
pub enum ControllerRequest {
    /// Sets various execution and error detection parameters. This may be
    /// called multiple times; only the most recently received options are used.
    /// If the `Options` parameter omits one or more fields, those parameters
    /// are unchanged in the fuzzer. Until the initial call to this method, the
    /// fuzzer should assume the default values for `Options`.
    ///
    /// + request `options` the execution and error detection parameters.
    /// * error one of the following:
    /// * error
    ///     * `ZX_ERR_BAD_STATE` if a long-running call such as `Execute`,
    ///       `Cleanse`, `Minimize`, `Fuzz`, or `Merge` is in progress.
    ///     * `ZX_ERR_NOT_SUPPORTED` if a value provided for an option is not
    ///       supported by the engine. Check the logs for additional details.
    Configure { options: Options, responder: ControllerConfigureResponder },
    /// Gets the current values for the various execution and error detection
    /// parameters.
    ///
    /// - response `options` the execution and error detection parameters.
    GetOptions { responder: ControllerGetOptionsResponder },
    /// Writes the provided `input` to either the "seed" or "live" `corpus`.
    /// Returns an error if transferring the input fails; see `Input` for
    /// details.
    ///
    /// + request `corpus` the type of corpus to add to.
    /// + request `input` the sequence of bytes to add as a test input.
    /// * error one of the following:
    ///     * `ZX_ERR_INVALID_ARGS` if corpus type is invalid.
    ///     * A socket error if transferring the input fails.
    AddToCorpus { corpus: Corpus, input: Input, responder: ControllerAddToCorpusResponder },
    /// Connects a `corpus_reader` for either the "seed" or "live" corpus.
    ///
    /// + request `corpus` the type of corpus to read from.
    /// + request `corpus_reader` the client used to send test inputs.
    ReadCorpus {
        corpus: Corpus,
        corpus_reader: fdomain_client::fidl::ClientEnd<CorpusReaderMarker>,
        responder: ControllerReadCorpusResponder,
    },
    /// Parses and loads an AFL-style dictionary. Invalid entries are logged and
    /// skipped.
    ///
    /// See also:
    ///
    /// * https://github.com/mirrorer/afl/blob/master/dictionaries/README.dictionaries
    ///
    /// + request `dictionary` the AFL-style dictionary
    /// * error one of the following:
    ///     * A socket error if transferring the input fails.
    ///     *`ZX_ERR_INVALID_ARGS` if parsing the dictionary fails.
    WriteDictionary { dictionary: Input, responder: ControllerWriteDictionaryResponder },
    /// Returns the current dictionary as an Input, which may be empty.
    ///
    /// - response `dictionary` the current AFL-style dictionary.
    ReadDictionary { responder: ControllerReadDictionaryResponder },
    /// Installs a `Monitor` to push status. To pull status instead, use
    /// `GetStatus`.
    ///
    /// + request `monitor` the client used to send status updates.
    AddMonitor {
        monitor: fdomain_client::fidl::ClientEnd<MonitorMarker>,
        responder: ControllerAddMonitorResponder,
    },
    /// Runs the normal fuzzing feedback loop:
    ///
    /// 1. Selects an input from the corpus.
    /// 2. Mutates the input.
    /// 3. Uses the `TargetAdapter` to execute the input.
    /// 4. Checks feedback from the `InstrumentedProcesses`.
    /// 5. If the input produced useful feedback, adds it to the corpus.
    ///
    /// This call returns quickly, but the loop continues until one of three
    /// conditions is met:
    ///
    /// 1. The configured, non-zero number of `runs` has been reached.
    /// 2. The configured, non-zero `duration` elapses.
    /// 3. An error is detected, and returned.
    ///
    /// See `Result` for more details on long running workflows such as this
    /// one.
    ///
    /// * error `ZX_ERR_BAD_STATE` if another long-running workflow is in
    ///   progress.
    Fuzz { responder: ControllerFuzzResponder },
    /// Executes the target code with a single `test_input`.
    ///
    /// See `Result` for more details on long running workflows such as this
    /// one.
    ///
    /// + request `input` the sequence of bytes to use with the fuzz target.
    /// * error one of the following:
    ///     * `ZX_ERR_BAD_STATE` if another long-running workflow is in
    ///       progress.
    ///     *  A socket error if transferring the input fails.
    TryOne { test_input: Input, responder: ControllerTryOneResponder },
    /// Attempts to find the smallest input that produces the same error as the
    /// given `test_input`,
    /// constrained by the configured `total_time` and/or `runs` options.
    ///
    /// See `Result` for more details on long running workflows such as this
    /// one.
    ///
    /// + request `input` the sequence of bytes to minimize.
    /// * error one of the following:
    ///     * `ZX_ERR_BAD_STATE` if another long-running workflow is in
    ///       progress.
    ///     * A socket error if transferring the input fails.
    ///     * `ZX_ERR_INVALID_ARGS` if the provided `test_input` does not cause
    ///       an error.
    Minimize { test_input: Input, responder: ControllerMinimizeResponder },
    /// Attempts to replace bytes of the given `test_input` with "filler" bytes,
    /// e.g. \x00, \xFF, without changing the error produced.
    ///
    /// See `Result` for more details on long running workflows such as this
    /// one.
    ///
    /// To preserve backwards compatibility with libFuzzer and ClusterFuzz, an
    /// input that produces no result is *not* considered an error, and is
    /// returned as-is.
    ///
    /// + request `input` the sequence of bytes to cleanse.
    /// * error one of the following:
    ///     * `ZX_ERR_BAD_STATE` if another long-running workflow is in
    ///       progress.
    ///     * A socket error if transferring the input fails.
    Cleanse { test_input: Input, responder: ControllerCleanseResponder },
    /// Attempts to shrink the corpora. Inputs from the seed corpus will be
    /// preserved. All other inputs will be sorted by amount of feedback
    /// produced and input size, and only those inputs that add new feedback not
    /// seen earlier in the sequence will be kept.
    ///
    /// See `Result` for more details on long running workflows such as this
    /// one.
    ///
    /// * error one of the following:
    ///     * `ZX_ERR_BAD_STATE` if another long-running workflow is in
    ///       progress.
    ///     * `ZX_ERR_INVALID_ARGS` if an input in the seed corpus causes an
    ///       error. Inputs in the live corpus that cause errors are skipped.
    Merge { responder: ControllerMergeResponder },
    /// Returns various fuzzing metrics, e.g. total coverage, speed, etc.
    ///
    /// - response `status` the current value of fuzzing metrics.
    GetStatus { responder: ControllerGetStatusResponder },
    /// Returns the results of a long-running workflow.
    ///
    /// This method uses the
    /// ["hanging get" pattern](https://fuchsia.dev/fuchsia-src/development/api/fidl#hanging-get).
    /// Upon the first call for a given connection, it will immediately return
    /// the controller's current artifact. Upon subsequent calls, it will block
    /// until the controller's artifact changes before returning. Clients should
    /// use `GetStatus` to ensure the fuzzer is not idle before making a
    /// blocking call to `WatchArtifact`.
    ///
    /// Combined with the `Status.running` value obtained from `GetStatus`, this
    /// allows a (re-)connecting client to infer the state of the fuzzer:
    ///
    /// * If the fuzzer is idle and has an empty artifact, then it is
    ///   unchanged since the last connection, if any.
    /// * If the fuzzer is running and has an empty artifact, then it is
    ///   performing a long-running workflow started by a previous connection.
    ///   The client may call `WatchArtifact` again to wait for the workflow
    ///   to complete.
    /// * If the fuzzer is idle and has a non-empty artifact, then it has
    ///   completed a long-running workflow since the last connection.
    ///
    /// It is not an error for clients to disconnect while waiting for a
    /// response from this method. This method is intended to allow clients to
    /// resume waiting for a long-running workflow to complete after
    /// intentionally or inadvertently being disconnected for an indefinite
    /// amount of time.
    ///
    /// - response `artifact` the most recent result and/or error-causing input.
    WatchArtifact { responder: ControllerWatchArtifactResponder },
}

impl ControllerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_configure(self) -> Option<(Options, ControllerConfigureResponder)> {
        if let ControllerRequest::Configure { options, responder } = self {
            Some((options, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_options(self) -> Option<(ControllerGetOptionsResponder)> {
        if let ControllerRequest::GetOptions { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_to_corpus(self) -> Option<(Corpus, Input, ControllerAddToCorpusResponder)> {
        if let ControllerRequest::AddToCorpus { corpus, input, responder } = self {
            Some((corpus, input, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_read_corpus(
        self,
    ) -> Option<(
        Corpus,
        fdomain_client::fidl::ClientEnd<CorpusReaderMarker>,
        ControllerReadCorpusResponder,
    )> {
        if let ControllerRequest::ReadCorpus { corpus, corpus_reader, responder } = self {
            Some((corpus, corpus_reader, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_write_dictionary(self) -> Option<(Input, ControllerWriteDictionaryResponder)> {
        if let ControllerRequest::WriteDictionary { dictionary, responder } = self {
            Some((dictionary, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_read_dictionary(self) -> Option<(ControllerReadDictionaryResponder)> {
        if let ControllerRequest::ReadDictionary { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_monitor(
        self,
    ) -> Option<(fdomain_client::fidl::ClientEnd<MonitorMarker>, ControllerAddMonitorResponder)>
    {
        if let ControllerRequest::AddMonitor { monitor, responder } = self {
            Some((monitor, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_fuzz(self) -> Option<(ControllerFuzzResponder)> {
        if let ControllerRequest::Fuzz { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_try_one(self) -> Option<(Input, ControllerTryOneResponder)> {
        if let ControllerRequest::TryOne { test_input, responder } = self {
            Some((test_input, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_minimize(self) -> Option<(Input, ControllerMinimizeResponder)> {
        if let ControllerRequest::Minimize { test_input, responder } = self {
            Some((test_input, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_cleanse(self) -> Option<(Input, ControllerCleanseResponder)> {
        if let ControllerRequest::Cleanse { test_input, responder } = self {
            Some((test_input, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_merge(self) -> Option<(ControllerMergeResponder)> {
        if let ControllerRequest::Merge { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_status(self) -> Option<(ControllerGetStatusResponder)> {
        if let ControllerRequest::GetStatus { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_watch_artifact(self) -> Option<(ControllerWatchArtifactResponder)> {
        if let ControllerRequest::WatchArtifact { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            ControllerRequest::Configure { .. } => "configure",
            ControllerRequest::GetOptions { .. } => "get_options",
            ControllerRequest::AddToCorpus { .. } => "add_to_corpus",
            ControllerRequest::ReadCorpus { .. } => "read_corpus",
            ControllerRequest::WriteDictionary { .. } => "write_dictionary",
            ControllerRequest::ReadDictionary { .. } => "read_dictionary",
            ControllerRequest::AddMonitor { .. } => "add_monitor",
            ControllerRequest::Fuzz { .. } => "fuzz",
            ControllerRequest::TryOne { .. } => "try_one",
            ControllerRequest::Minimize { .. } => "minimize",
            ControllerRequest::Cleanse { .. } => "cleanse",
            ControllerRequest::Merge { .. } => "merge",
            ControllerRequest::GetStatus { .. } => "get_status",
            ControllerRequest::WatchArtifact { .. } => "watch_artifact",
        }
    }
}

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

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

impl fdomain_client::fidl::ControlHandle for ControllerControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

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

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fdomain_client::OnFDomainSignals {
        self.inner.channel().on_closed()
    }
}

impl ControllerControlHandle {}

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

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

impl fdomain_client::fidl::Responder for ControllerConfigureResponder {
    type ControlHandle = ControllerControlHandle;

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

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

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

impl fdomain_client::fidl::Responder for ControllerGetOptionsResponder {
    type ControlHandle = ControllerControlHandle;

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

    fn send_raw(&self, mut options: &Options) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<ControllerGetOptionsResponse>(
            (options,),
            self.tx_id,
            0x683d93332504b9cd,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

impl fdomain_client::fidl::Responder for ControllerAddToCorpusResponder {
    type ControlHandle = ControllerControlHandle;

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

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

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

impl fdomain_client::fidl::Responder for ControllerReadCorpusResponder {
    type ControlHandle = ControllerControlHandle;

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

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

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

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

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

impl fdomain_client::fidl::Responder for ControllerWriteDictionaryResponder {
    type ControlHandle = ControllerControlHandle;

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

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

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

impl fdomain_client::fidl::Responder for ControllerReadDictionaryResponder {
    type ControlHandle = ControllerControlHandle;

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

    fn send_raw(&self, mut dictionary: Input) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<ControllerReadDictionaryResponse>(
            (&mut dictionary,),
            self.tx_id,
            0x1be6724c87b51c37,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

impl fdomain_client::fidl::Responder for ControllerAddMonitorResponder {
    type ControlHandle = ControllerControlHandle;

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

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

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

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

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

impl fdomain_client::fidl::Responder for ControllerFuzzResponder {
    type ControlHandle = ControllerControlHandle;

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

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

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

impl fdomain_client::fidl::Responder for ControllerTryOneResponder {
    type ControlHandle = ControllerControlHandle;

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

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

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

impl fdomain_client::fidl::Responder for ControllerMinimizeResponder {
    type ControlHandle = ControllerControlHandle;

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

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

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

impl fdomain_client::fidl::Responder for ControllerCleanseResponder {
    type ControlHandle = ControllerControlHandle;

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

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

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

impl fdomain_client::fidl::Responder for ControllerMergeResponder {
    type ControlHandle = ControllerControlHandle;

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

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

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

impl fdomain_client::fidl::Responder for ControllerGetStatusResponder {
    type ControlHandle = ControllerControlHandle;

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

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

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

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

impl fdomain_client::fidl::Responder for ControllerWatchArtifactResponder {
    type ControlHandle = ControllerControlHandle;

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

    fn send_raw(&self, mut artifact: Artifact) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<ControllerWatchArtifactResponse>(
            (&mut artifact,),
            self.tx_id,
            0x6cfca3730944a414,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fdomain_client::fidl::ProtocolMarker for ControllerProviderMarker {
    type Proxy = ControllerProviderProxy;
    type RequestStream = ControllerProviderRequestStream;

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

pub trait ControllerProviderProxyInterface: Send + Sync {
    type ConnectResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#connect(
        &self,
        controller: fdomain_client::fidl::ServerEnd<ControllerMarker>,
    ) -> Self::ConnectResponseFut;
    fn r#stop(&self) -> Result<(), fidl::Error>;
}

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

impl fdomain_client::fidl::Proxy for ControllerProviderProxy {
    type Protocol = ControllerProviderMarker;

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

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

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

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

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

    /// Connects a client to the fuzzer.
    ///
    /// Within the component fuzzing framework, the fuzz-manager forwards
    /// `Controller` connection requests to the fuzz-registry, which uses
    /// clients of this interface provided by the fuzzers themselves to perform
    /// the connection.
    ///
    /// At most one client can be connected to a controller at any given time.
    /// A subsequent call to `Connect` will preempt and replace the existing
    /// connection.
    ///
    /// + request `controller` the connection from the client.
    pub fn r#connect(
        &self,
        mut controller: fdomain_client::fidl::ServerEnd<ControllerMarker>,
    ) -> fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect> {
        ControllerProviderProxyInterface::r#connect(self, controller)
    }

    /// Interrupt any current workflow, closes the channel, and exits the
    /// fuzzing engine.
    pub fn r#stop(&self) -> Result<(), fidl::Error> {
        ControllerProviderProxyInterface::r#stop(self)
    }
}

impl ControllerProviderProxyInterface for ControllerProviderProxy {
    type ConnectResponseFut =
        fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect>;
    fn r#connect(
        &self,
        mut controller: fdomain_client::fidl::ServerEnd<ControllerMarker>,
    ) -> Self::ConnectResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fdomain_client::fidl::FDomainResourceDialect,
                0xc0325f0732defcb,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<ControllerProviderConnectRequest, ()>(
            (controller,),
            0xc0325f0732defcb,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#stop(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x6cd6a98fc38bcbf2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for ControllerProviderRequestStream {
    type Protocol = ControllerProviderMarker;
    type ControlHandle = ControllerProviderControlHandle;

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                0xc0325f0732defcb => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(ControllerProviderConnectRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<ControllerProviderConnectRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = ControllerProviderControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(ControllerProviderRequest::Connect {controller: req.controller,

                        responder: ControllerProviderConnectResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x6cd6a98fc38bcbf2 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = ControllerProviderControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(ControllerProviderRequest::Stop {
                        control_handle,
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <ControllerProviderMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// Provides a `Controller` implementation.
///
/// This protocol is implemented by the fuzzing engine. This capability is *not*
/// routed. Instead, the engine uses the `fuchsia.fuzzer/Registry` channel
/// provided by the fuzz-test-runner to send the client end of this interface to
/// the fuzz-registry.
///
/// The fuzz-registry will close the channel upon error, or upon its own exit.
/// The fuzzer should exit and not attempt to reconnect when on channel close.
#[derive(Debug)]
pub enum ControllerProviderRequest {
    /// Connects a client to the fuzzer.
    ///
    /// Within the component fuzzing framework, the fuzz-manager forwards
    /// `Controller` connection requests to the fuzz-registry, which uses
    /// clients of this interface provided by the fuzzers themselves to perform
    /// the connection.
    ///
    /// At most one client can be connected to a controller at any given time.
    /// A subsequent call to `Connect` will preempt and replace the existing
    /// connection.
    ///
    /// + request `controller` the connection from the client.
    Connect {
        controller: fdomain_client::fidl::ServerEnd<ControllerMarker>,
        responder: ControllerProviderConnectResponder,
    },
    /// Interrupt any current workflow, closes the channel, and exits the
    /// fuzzing engine.
    Stop { control_handle: ControllerProviderControlHandle },
}

impl ControllerProviderRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_connect(
        self,
    ) -> Option<(
        fdomain_client::fidl::ServerEnd<ControllerMarker>,
        ControllerProviderConnectResponder,
    )> {
        if let ControllerProviderRequest::Connect { controller, responder } = self {
            Some((controller, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_stop(self) -> Option<(ControllerProviderControlHandle)> {
        if let ControllerProviderRequest::Stop { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            ControllerProviderRequest::Connect { .. } => "connect",
            ControllerProviderRequest::Stop { .. } => "stop",
        }
    }
}

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

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

impl fdomain_client::fidl::ControlHandle for ControllerProviderControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

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

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fdomain_client::OnFDomainSignals {
        self.inner.channel().on_closed()
    }
}

impl ControllerProviderControlHandle {}

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

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

impl fdomain_client::fidl::Responder for ControllerProviderConnectResponder {
    type ControlHandle = ControllerProviderControlHandle;

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

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

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

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

impl fdomain_client::fidl::ProtocolMarker for CorpusReaderMarker {
    type Proxy = CorpusReaderProxy;
    type RequestStream = CorpusReaderRequestStream;

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

pub trait CorpusReaderProxyInterface: Send + Sync {
    type NextResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#next(&self, test_input: Input) -> Self::NextResponseFut;
}

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

impl fdomain_client::fidl::Proxy for CorpusReaderProxy {
    type Protocol = CorpusReaderMarker;

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

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

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

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

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

    /// Sends the next test input from the corpus.
    ///
    /// + request `test_input` the byte sequence representing the next test
    ///   input in a corpus.
    /// - response `result` one of the following:
    ///     - `ZX_OK` if the test input was sent.
    ///     - A socket error if transferring the input failed.
    pub fn r#next(
        &self,
        mut test_input: Input,
    ) -> fidl::client::QueryResponseFut<i32, fdomain_client::fidl::FDomainResourceDialect> {
        CorpusReaderProxyInterface::r#next(self, test_input)
    }
}

impl CorpusReaderProxyInterface for CorpusReaderProxy {
    type NextResponseFut =
        fidl::client::QueryResponseFut<i32, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#next(&self, mut test_input: Input) -> Self::NextResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                CorpusReaderNextResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x68d19e55ea635356,
            >(_buf?)?;
            Ok(_response.result)
        }
        self.client.send_query_and_decode::<CorpusReaderNextRequest, i32>(
            (&mut test_input,),
            0x68d19e55ea635356,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for CorpusReaderRequestStream {
    type Protocol = CorpusReaderMarker;
    type ControlHandle = CorpusReaderControlHandle;

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x68d19e55ea635356 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            CorpusReaderNextRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<CorpusReaderNextRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            CorpusReaderControlHandle { inner: this.inner.clone() };
                        Ok(CorpusReaderRequest::Next {
                            test_input: req.test_input,

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

/// Sends a sequence of test inputs belonging to a fuzzer's corpus.
#[derive(Debug)]
pub enum CorpusReaderRequest {
    /// Sends the next test input from the corpus.
    ///
    /// + request `test_input` the byte sequence representing the next test
    ///   input in a corpus.
    /// - response `result` one of the following:
    ///     - `ZX_OK` if the test input was sent.
    ///     - A socket error if transferring the input failed.
    Next { test_input: Input, responder: CorpusReaderNextResponder },
}

impl CorpusReaderRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_next(self) -> Option<(Input, CorpusReaderNextResponder)> {
        if let CorpusReaderRequest::Next { test_input, responder } = self {
            Some((test_input, responder))
        } else {
            None
        }
    }

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

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

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

impl fdomain_client::fidl::ControlHandle for CorpusReaderControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

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

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fdomain_client::OnFDomainSignals {
        self.inner.channel().on_closed()
    }
}

impl CorpusReaderControlHandle {}

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

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

impl fdomain_client::fidl::Responder for CorpusReaderNextResponder {
    type ControlHandle = CorpusReaderControlHandle;

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

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

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

impl fdomain_client::fidl::ProtocolMarker for CoverageDataCollectorMarker {
    type Proxy = CoverageDataCollectorProxy;
    type RequestStream = CoverageDataCollectorRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.fuzzer.CoverageDataCollector";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for CoverageDataCollectorMarker {}

pub trait CoverageDataCollectorProxyInterface: Send + Sync {
    type InitializeResponseFut: std::future::Future<Output = Result<Options, fidl::Error>> + Send;
    fn r#initialize(
        &self,
        eventpair: fdomain_client::EventPair,
        process: fdomain_client::Process,
    ) -> Self::InitializeResponseFut;
    type AddInline8bitCountersResponseFut: std::future::Future<Output = Result<(), fidl::Error>>
        + Send;
    fn r#add_inline8bit_counters(
        &self,
        inline_8bit_counters: fdomain_client::Vmo,
    ) -> Self::AddInline8bitCountersResponseFut;
}

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

impl fdomain_client::fidl::Proxy for CoverageDataCollectorProxy {
    type Protocol = CoverageDataCollectorMarker;

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

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

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

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

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

    /// Registers the instrumented target process.
    ///
    /// This method is called once per connection to set up:
    ///    * The eventpair used to synchronize the start and end of code coverage collection.
    ///    * The process Handle used to monitor the target process for errors.
    ///
    /// This method must be called before the target process can call `AddLlvmModule`.
    ///
    /// It returns the currently set options; see `fuchsia.fuzzer.Controller/Configure`.
    ///
    /// Certain options determine sanitizer behaviors before `main` is called, and cannot
    /// subsequently be changed while the target process is running. This is the root cause of the
    /// constraint in `Controller` against modifying options during "long-running workflows", i.e
    /// those that spawn target processes.
    ///
    /// The channel is closed on FIDL error. Clients should not attempt to reconnect.
    pub fn r#initialize(
        &self,
        mut eventpair: fdomain_client::EventPair,
        mut process: fdomain_client::Process,
    ) -> fidl::client::QueryResponseFut<Options, fdomain_client::fidl::FDomainResourceDialect> {
        CoverageDataCollectorProxyInterface::r#initialize(self, eventpair, process)
    }

    /// Adds a VMO with the code coverage of an LLVM module.
    ///
    /// The VMO used to share inline 8-bit code-coverage edge counters for a single LLVM module in
    /// an instrumented target process.
    ///
    /// Its ZX_PROP_NAME property must be set, and client and server implementations must agree on
    /// how to use it to uniquely identify the module. If the same module is added more than once by
    /// different processes, the module identifiers must match so that the code counters can be
    /// combined.
    ///
    /// Its ZX_PROP_VMO_CONTENT_SIZE property must be set to the actual number of counters present.
    ///
    /// It is an error to call this method without first calling |Initialize|.
    ///
    /// The channel is closed on FIDL error. Clients should not attempt to reconnect.
    ///
    /// See also:
    ///     https://clang.llvm.org/docs/SanitizerCoverage.html#inline-8bit-counters
    pub fn r#add_inline8bit_counters(
        &self,
        mut inline_8bit_counters: fdomain_client::Vmo,
    ) -> fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect> {
        CoverageDataCollectorProxyInterface::r#add_inline8bit_counters(self, inline_8bit_counters)
    }
}

impl CoverageDataCollectorProxyInterface for CoverageDataCollectorProxy {
    type InitializeResponseFut =
        fidl::client::QueryResponseFut<Options, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#initialize(
        &self,
        mut eventpair: fdomain_client::EventPair,
        mut process: fdomain_client::Process,
    ) -> Self::InitializeResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Options, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                CoverageDataCollectorInitializeResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x51d6f91d6f02d9d6,
            >(_buf?)?;
            Ok(_response.options)
        }
        self.client.send_query_and_decode::<CoverageDataCollectorInitializeRequest, Options>(
            (eventpair, process),
            0x51d6f91d6f02d9d6,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type AddInline8bitCountersResponseFut =
        fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect>;
    fn r#add_inline8bit_counters(
        &self,
        mut inline_8bit_counters: fdomain_client::Vmo,
    ) -> Self::AddInline8bitCountersResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fdomain_client::fidl::FDomainResourceDialect,
                0x75f87cadfc94d1be,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<CoverageDataCollectorAddInline8bitCountersRequest, ()>(
            (inline_8bit_counters,),
            0x75f87cadfc94d1be,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for CoverageDataCollectorRequestStream {
    type Protocol = CoverageDataCollectorMarker;
    type ControlHandle = CoverageDataCollectorControlHandle;

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                0x51d6f91d6f02d9d6 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(CoverageDataCollectorInitializeRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<CoverageDataCollectorInitializeRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = CoverageDataCollectorControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(CoverageDataCollectorRequest::Initialize {eventpair: req.eventpair,
process: req.process,

                        responder: CoverageDataCollectorInitializeResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x75f87cadfc94d1be => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(CoverageDataCollectorAddInline8bitCountersRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<CoverageDataCollectorAddInline8bitCountersRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = CoverageDataCollectorControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(CoverageDataCollectorRequest::AddInline8bitCounters {inline_8bit_counters: req.inline_8bit_counters,

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

/// Collects VMOs used to share code coverage from instrumented target processes.
///
/// The instrumented target processes act as clients to this protocol, which is implemented by
/// test_manager's fuzz_coverage component. The protocol coordinates feedback collection and other
/// diagnostics with target processes under test. The connection should be established very early in
/// a target process's lifecycle, i.e. before `main` begins.
#[derive(Debug)]
pub enum CoverageDataCollectorRequest {
    /// Registers the instrumented target process.
    ///
    /// This method is called once per connection to set up:
    ///    * The eventpair used to synchronize the start and end of code coverage collection.
    ///    * The process Handle used to monitor the target process for errors.
    ///
    /// This method must be called before the target process can call `AddLlvmModule`.
    ///
    /// It returns the currently set options; see `fuchsia.fuzzer.Controller/Configure`.
    ///
    /// Certain options determine sanitizer behaviors before `main` is called, and cannot
    /// subsequently be changed while the target process is running. This is the root cause of the
    /// constraint in `Controller` against modifying options during "long-running workflows", i.e
    /// those that spawn target processes.
    ///
    /// The channel is closed on FIDL error. Clients should not attempt to reconnect.
    Initialize {
        eventpair: fdomain_client::EventPair,
        process: fdomain_client::Process,
        responder: CoverageDataCollectorInitializeResponder,
    },
    /// Adds a VMO with the code coverage of an LLVM module.
    ///
    /// The VMO used to share inline 8-bit code-coverage edge counters for a single LLVM module in
    /// an instrumented target process.
    ///
    /// Its ZX_PROP_NAME property must be set, and client and server implementations must agree on
    /// how to use it to uniquely identify the module. If the same module is added more than once by
    /// different processes, the module identifiers must match so that the code counters can be
    /// combined.
    ///
    /// Its ZX_PROP_VMO_CONTENT_SIZE property must be set to the actual number of counters present.
    ///
    /// It is an error to call this method without first calling |Initialize|.
    ///
    /// The channel is closed on FIDL error. Clients should not attempt to reconnect.
    ///
    /// See also:
    ///     https://clang.llvm.org/docs/SanitizerCoverage.html#inline-8bit-counters
    AddInline8bitCounters {
        inline_8bit_counters: fdomain_client::Vmo,
        responder: CoverageDataCollectorAddInline8bitCountersResponder,
    },
}

impl CoverageDataCollectorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_initialize(
        self,
    ) -> Option<(
        fdomain_client::EventPair,
        fdomain_client::Process,
        CoverageDataCollectorInitializeResponder,
    )> {
        if let CoverageDataCollectorRequest::Initialize { eventpair, process, responder } = self {
            Some((eventpair, process, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_inline8bit_counters(
        self,
    ) -> Option<(fdomain_client::Vmo, CoverageDataCollectorAddInline8bitCountersResponder)> {
        if let CoverageDataCollectorRequest::AddInline8bitCounters {
            inline_8bit_counters,
            responder,
        } = self
        {
            Some((inline_8bit_counters, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            CoverageDataCollectorRequest::Initialize { .. } => "initialize",
            CoverageDataCollectorRequest::AddInline8bitCounters { .. } => "add_inline8bit_counters",
        }
    }
}

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

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

impl fdomain_client::fidl::ControlHandle for CoverageDataCollectorControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

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

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fdomain_client::OnFDomainSignals {
        self.inner.channel().on_closed()
    }
}

impl CoverageDataCollectorControlHandle {}

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

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

impl fdomain_client::fidl::Responder for CoverageDataCollectorInitializeResponder {
    type ControlHandle = CoverageDataCollectorControlHandle;

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

    fn send_raw(&self, mut options: &Options) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<CoverageDataCollectorInitializeResponse>(
            (options,),
            self.tx_id,
            0x51d6f91d6f02d9d6,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

impl fdomain_client::fidl::Responder for CoverageDataCollectorAddInline8bitCountersResponder {
    type ControlHandle = CoverageDataCollectorControlHandle;

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

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

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

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

impl fdomain_client::fidl::ProtocolMarker for CoverageDataProviderMarker {
    type Proxy = CoverageDataProviderProxy;
    type RequestStream = CoverageDataProviderRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.fuzzer.CoverageDataProvider";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for CoverageDataProviderMarker {}

pub trait CoverageDataProviderProxyInterface: Send + Sync {
    fn r#set_options(&self, options: &Options) -> Result<(), fidl::Error>;
    type WatchCoverageDataResponseFut: std::future::Future<Output = Result<Vec<CoverageData>, fidl::Error>>
        + Send;
    fn r#watch_coverage_data(&self) -> Self::WatchCoverageDataResponseFut;
}

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

impl fdomain_client::fidl::Proxy for CoverageDataProviderProxy {
    type Protocol = CoverageDataProviderMarker;

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

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

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

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

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

    /// Sets the options to be returned by `fuchsia.fuzzer.CoverageDataCollector/Initialize`.
    pub fn r#set_options(&self, mut options: &Options) -> Result<(), fidl::Error> {
        CoverageDataProviderProxyInterface::r#set_options(self, options)
    }

    /// Provides coverage data collected from multiple processes.
    ///
    /// Returns a vector of `CoverageData` structs containing the information provided by clients of
    /// `fuchsia.fuzzer.CoverageDataCollector`. This method uses the "hanging get" pattern: The
    /// initial call will immediately return whatever data is available, up to `MAX_COVERAGE_DATA`.
    /// If no fuzzed components have been started yet, this be an empty vector. If there are more
    /// than `MAX_COVERAGE_DATA` elements available, the remainder are retained for subsequent
    /// calls. If there is no more data available, subsequent calls will block until new coverage
    /// data is available.
    ///
    /// The channel is closed on FIDL error. Clients should exit and not attempt to reconnect.
    pub fn r#watch_coverage_data(
        &self,
    ) -> fidl::client::QueryResponseFut<
        Vec<CoverageData>,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        CoverageDataProviderProxyInterface::r#watch_coverage_data(self)
    }
}

impl CoverageDataProviderProxyInterface for CoverageDataProviderProxy {
    fn r#set_options(&self, mut options: &Options) -> Result<(), fidl::Error> {
        self.client.send::<CoverageDataProviderSetOptionsRequest>(
            (options,),
            0x4873c4a5c7683384,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type WatchCoverageDataResponseFut = fidl::client::QueryResponseFut<
        Vec<CoverageData>,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#watch_coverage_data(&self) -> Self::WatchCoverageDataResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<CoverageData>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                CoverageDataProviderWatchCoverageDataResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x34a92fc9c73bea5a,
            >(_buf?)?;
            Ok(_response.coverage_data)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<CoverageData>>(
            (),
            0x34a92fc9c73bea5a,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for CoverageDataProviderRequestStream {
    type Protocol = CoverageDataProviderMarker;
    type ControlHandle = CoverageDataProviderControlHandle;

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                0x4873c4a5c7683384 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(CoverageDataProviderSetOptionsRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<CoverageDataProviderSetOptionsRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = CoverageDataProviderControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(CoverageDataProviderRequest::SetOptions {options: req.options,

                        control_handle,
                    })
                }
                0x34a92fc9c73bea5a => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = CoverageDataProviderControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(CoverageDataProviderRequest::WatchCoverageData {
                        responder: CoverageDataProviderWatchCoverageDataResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <CoverageDataProviderMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// Provides the process Handles and VMOs used to share code coverage to the fuzzing engine.
///
/// This protocol is implemented by `test_manager`'s `fuzz_coverage` component. The fuzzing engine
/// acts as a client, although it does not connect directly. Instead the `fuzz_test_runner` makes
/// the connection and passes it off to fuzzing engine on process start. It allows the engine to
/// retrieve the coverage-related Handles published by instrumented target processes.
///
/// The channel is closed on FIDL error. Clients should exit and not attempt to reconnect.
#[derive(Debug)]
pub enum CoverageDataProviderRequest {
    /// Sets the options to be returned by `fuchsia.fuzzer.CoverageDataCollector/Initialize`.
    SetOptions { options: Options, control_handle: CoverageDataProviderControlHandle },
    /// Provides coverage data collected from multiple processes.
    ///
    /// Returns a vector of `CoverageData` structs containing the information provided by clients of
    /// `fuchsia.fuzzer.CoverageDataCollector`. This method uses the "hanging get" pattern: The
    /// initial call will immediately return whatever data is available, up to `MAX_COVERAGE_DATA`.
    /// If no fuzzed components have been started yet, this be an empty vector. If there are more
    /// than `MAX_COVERAGE_DATA` elements available, the remainder are retained for subsequent
    /// calls. If there is no more data available, subsequent calls will block until new coverage
    /// data is available.
    ///
    /// The channel is closed on FIDL error. Clients should exit and not attempt to reconnect.
    WatchCoverageData { responder: CoverageDataProviderWatchCoverageDataResponder },
}

impl CoverageDataProviderRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_set_options(self) -> Option<(Options, CoverageDataProviderControlHandle)> {
        if let CoverageDataProviderRequest::SetOptions { options, control_handle } = self {
            Some((options, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_watch_coverage_data(
        self,
    ) -> Option<(CoverageDataProviderWatchCoverageDataResponder)> {
        if let CoverageDataProviderRequest::WatchCoverageData { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            CoverageDataProviderRequest::SetOptions { .. } => "set_options",
            CoverageDataProviderRequest::WatchCoverageData { .. } => "watch_coverage_data",
        }
    }
}

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

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

impl fdomain_client::fidl::ControlHandle for CoverageDataProviderControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

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

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fdomain_client::OnFDomainSignals {
        self.inner.channel().on_closed()
    }
}

impl CoverageDataProviderControlHandle {}

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

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

impl fdomain_client::fidl::Responder for CoverageDataProviderWatchCoverageDataResponder {
    type ControlHandle = CoverageDataProviderControlHandle;

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

    fn send_raw(&self, mut coverage_data: Vec<CoverageData>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<CoverageDataProviderWatchCoverageDataResponse>(
            (coverage_data.as_mut(),),
            self.tx_id,
            0x34a92fc9c73bea5a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fdomain_client::fidl::ProtocolMarker for ManagerMarker {
    type Proxy = ManagerProxy;
    type RequestStream = ManagerRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.fuzzer.Manager";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for ManagerMarker {}
pub type ManagerConnectResult = Result<(), i32>;
pub type ManagerGetOutputResult = Result<(), i32>;
pub type ManagerStopResult = Result<(), i32>;

pub trait ManagerProxyInterface: Send + Sync {
    type ConnectResponseFut: std::future::Future<Output = Result<ManagerConnectResult, fidl::Error>>
        + Send;
    fn r#connect(
        &self,
        fuzzer_url: &str,
        controller: fdomain_client::fidl::ServerEnd<ControllerMarker>,
    ) -> Self::ConnectResponseFut;
    type GetOutputResponseFut: std::future::Future<Output = Result<ManagerGetOutputResult, fidl::Error>>
        + Send;
    fn r#get_output(
        &self,
        fuzzer_url: &str,
        output: TestOutput,
        socket: fdomain_client::Socket,
    ) -> Self::GetOutputResponseFut;
    type StopResponseFut: std::future::Future<Output = Result<ManagerStopResult, fidl::Error>>
        + Send;
    fn r#stop(&self, fuzzer_url: &str) -> Self::StopResponseFut;
}

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

impl fdomain_client::fidl::Proxy for ManagerProxy {
    type Protocol = ManagerMarker;

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

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

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

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

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

    /// Connects to a fuzzer that implements the `fuchsia.fuzzer/Controller`
    /// protocol.
    ///
    /// If the fuzzer is not currently running, the `fuzz_manager` will first
    /// start it (via the test_manager) before proceeding. The `fuzz_manager`
    /// sends the `controller` on to the fuzz-registry, which contains the
    /// `ControllerProviders` that can fulfill the connection request.
    ///
    /// See `fuchsia.test.manager/LaunchError` for details on ways
    /// `test_manager` can fail.
    ///
    /// + request `fuzzer_url` the package URL for the fuzzer.
    /// + request `controller` the connection from the client.
    /// * error one of the following:
    ///     * `ZX_ERR_NO_RESOURCES` if `test_manager` needs resources that are
    ///       unavailable.
    ///     * `ZX_ERR_NOT_FOUND` if the fuzzer URL is not recognized by
    ///       `test_manager`.
    ///     * `ZX_ERR_INVALID_ARGS` if `test_manager` reports invalid arguments.
    ///     * `ZX_ERR_NOT_SUPPORTED` if `test_manager` cannot connect to the
    ///       test suite.
    ///     * `ZX_ERR_INTERNAL` if `test_manager` encountered some other,
    ///       unspecified failure.
    ///     * `ZX_ERR_TIMED_OUT` if the fuzzer is not present or added to
    ///       fuzz-registry after starting.
    ///     * `ZX_ERR_SHOULD_WAIT` if another fuzzer is still starting.
    pub fn r#connect(
        &self,
        mut fuzzer_url: &str,
        mut controller: fdomain_client::fidl::ServerEnd<ControllerMarker>,
    ) -> fidl::client::QueryResponseFut<
        ManagerConnectResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        ManagerProxyInterface::r#connect(self, fuzzer_url, controller)
    }

    /// Forwards the fuzzer's output of the given type to the provided socket.
    ///
    /// If this method is called multiple times for the same output type, the
    /// socket from the subsequent call replaces the socket from the earlier
    /// call, which is closed.
    ///
    /// + request `fuzzer_url` the package URL for the fuzzer.
    /// + request `output` the type of the output stream to forward.
    /// + request `socket` a socket to forward the output stream to.
    /// * error one of the following:
    ///     * `ZX_ERR_INVALID_ARGS` if the URL cannot be parsed.
    ///     * `ZX_ERR_NOT_FOUND` if the fuzzer URL was not recognized by
    ///       `test_manager`.
    ///     * `ZX_ERR_BAD_STATE` if the fuzzer is not connected.
    pub fn r#get_output(
        &self,
        mut fuzzer_url: &str,
        mut output: TestOutput,
        mut socket: fdomain_client::Socket,
    ) -> fidl::client::QueryResponseFut<
        ManagerGetOutputResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        ManagerProxyInterface::r#get_output(self, fuzzer_url, output, socket)
    }

    /// Stops the associated fuzzer immediately, ending any workflows in
    /// progress.
    ///
    /// + request `fuzzer_url` the package URL for the fuzzer.
    /// * error `ZX_ERR_NOT_FOUND` if no fuzzer was active with the given URL.
    pub fn r#stop(
        &self,
        mut fuzzer_url: &str,
    ) -> fidl::client::QueryResponseFut<
        ManagerStopResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        ManagerProxyInterface::r#stop(self, fuzzer_url)
    }
}

impl ManagerProxyInterface for ManagerProxy {
    type ConnectResponseFut = fidl::client::QueryResponseFut<
        ManagerConnectResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#connect(
        &self,
        mut fuzzer_url: &str,
        mut controller: fdomain_client::fidl::ServerEnd<ControllerMarker>,
    ) -> Self::ConnectResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ManagerConnectResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x1620cd742a89f064,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<ManagerConnectRequest, ManagerConnectResult>(
            (fuzzer_url, controller),
            0x1620cd742a89f064,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetOutputResponseFut = fidl::client::QueryResponseFut<
        ManagerGetOutputResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_output(
        &self,
        mut fuzzer_url: &str,
        mut output: TestOutput,
        mut socket: fdomain_client::Socket,
    ) -> Self::GetOutputResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ManagerGetOutputResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x755c28eecf20a88d,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<ManagerGetOutputRequest, ManagerGetOutputResult>(
            (fuzzer_url, output, socket),
            0x755c28eecf20a88d,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for ManagerRequestStream {
    type Protocol = ManagerMarker;
    type ControlHandle = ManagerControlHandle;

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x1620cd742a89f064 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ManagerConnectRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<ManagerConnectRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ManagerControlHandle { inner: this.inner.clone() };
                        Ok(ManagerRequest::Connect {
                            fuzzer_url: req.fuzzer_url,
                            controller: req.controller,

                            responder: ManagerConnectResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x755c28eecf20a88d => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ManagerGetOutputRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<ManagerGetOutputRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ManagerControlHandle { inner: this.inner.clone() };
                        Ok(ManagerRequest::GetOutput {
                            fuzzer_url: req.fuzzer_url,
                            output: req.output,
                            socket: req.socket,

                            responder: ManagerGetOutputResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x27e53d86badd21f3 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ManagerStopRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<ManagerStopRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ManagerControlHandle { inner: this.inner.clone() };
                        Ok(ManagerRequest::Stop {
                            fuzzer_url: req.fuzzer_url,

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

/// Entry point for users, e.g. `ffx fuzz`, used to start and stop fuzzers. A
/// fuzzer will be started on the first call to `Connect` with a given URL.
/// Closing the given `Controller` channel does *not* stop the associated
/// fuzzer. Instead, since fuzzing is meant to be long-running, clients
/// may drop the connection and re-`Connect` some time later.
#[derive(Debug)]
pub enum ManagerRequest {
    /// Connects to a fuzzer that implements the `fuchsia.fuzzer/Controller`
    /// protocol.
    ///
    /// If the fuzzer is not currently running, the `fuzz_manager` will first
    /// start it (via the test_manager) before proceeding. The `fuzz_manager`
    /// sends the `controller` on to the fuzz-registry, which contains the
    /// `ControllerProviders` that can fulfill the connection request.
    ///
    /// See `fuchsia.test.manager/LaunchError` for details on ways
    /// `test_manager` can fail.
    ///
    /// + request `fuzzer_url` the package URL for the fuzzer.
    /// + request `controller` the connection from the client.
    /// * error one of the following:
    ///     * `ZX_ERR_NO_RESOURCES` if `test_manager` needs resources that are
    ///       unavailable.
    ///     * `ZX_ERR_NOT_FOUND` if the fuzzer URL is not recognized by
    ///       `test_manager`.
    ///     * `ZX_ERR_INVALID_ARGS` if `test_manager` reports invalid arguments.
    ///     * `ZX_ERR_NOT_SUPPORTED` if `test_manager` cannot connect to the
    ///       test suite.
    ///     * `ZX_ERR_INTERNAL` if `test_manager` encountered some other,
    ///       unspecified failure.
    ///     * `ZX_ERR_TIMED_OUT` if the fuzzer is not present or added to
    ///       fuzz-registry after starting.
    ///     * `ZX_ERR_SHOULD_WAIT` if another fuzzer is still starting.
    Connect {
        fuzzer_url: String,
        controller: fdomain_client::fidl::ServerEnd<ControllerMarker>,
        responder: ManagerConnectResponder,
    },
    /// Forwards the fuzzer's output of the given type to the provided socket.
    ///
    /// If this method is called multiple times for the same output type, the
    /// socket from the subsequent call replaces the socket from the earlier
    /// call, which is closed.
    ///
    /// + request `fuzzer_url` the package URL for the fuzzer.
    /// + request `output` the type of the output stream to forward.
    /// + request `socket` a socket to forward the output stream to.
    /// * error one of the following:
    ///     * `ZX_ERR_INVALID_ARGS` if the URL cannot be parsed.
    ///     * `ZX_ERR_NOT_FOUND` if the fuzzer URL was not recognized by
    ///       `test_manager`.
    ///     * `ZX_ERR_BAD_STATE` if the fuzzer is not connected.
    GetOutput {
        fuzzer_url: String,
        output: TestOutput,
        socket: fdomain_client::Socket,
        responder: ManagerGetOutputResponder,
    },
    /// Stops the associated fuzzer immediately, ending any workflows in
    /// progress.
    ///
    /// + request `fuzzer_url` the package URL for the fuzzer.
    /// * error `ZX_ERR_NOT_FOUND` if no fuzzer was active with the given URL.
    Stop { fuzzer_url: String, responder: ManagerStopResponder },
}

impl ManagerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_connect(
        self,
    ) -> Option<(String, fdomain_client::fidl::ServerEnd<ControllerMarker>, ManagerConnectResponder)>
    {
        if let ManagerRequest::Connect { fuzzer_url, controller, responder } = self {
            Some((fuzzer_url, controller, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_output(
        self,
    ) -> Option<(String, TestOutput, fdomain_client::Socket, ManagerGetOutputResponder)> {
        if let ManagerRequest::GetOutput { fuzzer_url, output, socket, responder } = self {
            Some((fuzzer_url, output, socket, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_stop(self) -> Option<(String, ManagerStopResponder)> {
        if let ManagerRequest::Stop { fuzzer_url, responder } = self {
            Some((fuzzer_url, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            ManagerRequest::Connect { .. } => "connect",
            ManagerRequest::GetOutput { .. } => "get_output",
            ManagerRequest::Stop { .. } => "stop",
        }
    }
}

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

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

impl fdomain_client::fidl::ControlHandle for ManagerControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

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

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fdomain_client::OnFDomainSignals {
        self.inner.channel().on_closed()
    }
}

impl ManagerControlHandle {}

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

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

impl fdomain_client::fidl::Responder for ManagerConnectResponder {
    type ControlHandle = ManagerControlHandle;

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

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

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

impl fdomain_client::fidl::Responder for ManagerGetOutputResponder {
    type ControlHandle = ManagerControlHandle;

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

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

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

impl fdomain_client::fidl::Responder for ManagerStopResponder {
    type ControlHandle = ManagerControlHandle;

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

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

impl fdomain_client::fidl::ProtocolMarker for MonitorMarker {
    type Proxy = MonitorProxy;
    type RequestStream = MonitorRequestStream;

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

pub trait MonitorProxyInterface: Send + Sync {
    type UpdateResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#update(&self, reason: UpdateReason, status: &Status) -> Self::UpdateResponseFut;
}

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

impl fdomain_client::fidl::Proxy for MonitorProxy {
    type Protocol = MonitorMarker;

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

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

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

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

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

    /// Sends the current status.
    ///
    /// + request `reason` the cause of a status change.
    /// + status `status` the reported fuzzing metrics.
    pub fn r#update(
        &self,
        mut reason: UpdateReason,
        mut status: &Status,
    ) -> fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect> {
        MonitorProxyInterface::r#update(self, reason, status)
    }
}

impl MonitorProxyInterface for MonitorProxy {
    type UpdateResponseFut =
        fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect>;
    fn r#update(&self, mut reason: UpdateReason, mut status: &Status) -> Self::UpdateResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fdomain_client::fidl::FDomainResourceDialect,
                0x7c773b93c1e6080f,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<MonitorUpdateRequest, ()>(
            (reason, status),
            0x7c773b93c1e6080f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for MonitorRequestStream {
    type Protocol = MonitorMarker;
    type ControlHandle = MonitorControlHandle;

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x7c773b93c1e6080f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            MonitorUpdateRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<MonitorUpdateRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = MonitorControlHandle { inner: this.inner.clone() };
                        Ok(MonitorRequest::Update {
                            reason: req.reason,
                            status: req.status,

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

/// See `Status`. This protocol is used to push status from the `Controller` to
/// callers.
#[derive(Debug)]
pub enum MonitorRequest {
    /// Sends the current status.
    ///
    /// + request `reason` the cause of a status change.
    /// + status `status` the reported fuzzing metrics.
    Update { reason: UpdateReason, status: Status, responder: MonitorUpdateResponder },
}

impl MonitorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_update(self) -> Option<(UpdateReason, Status, MonitorUpdateResponder)> {
        if let MonitorRequest::Update { reason, status, responder } = self {
            Some((reason, status, responder))
        } else {
            None
        }
    }

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

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

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

impl fdomain_client::fidl::ControlHandle for MonitorControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

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

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fdomain_client::OnFDomainSignals {
        self.inner.channel().on_closed()
    }
}

impl MonitorControlHandle {}

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

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

impl fdomain_client::fidl::Responder for MonitorUpdateResponder {
    type ControlHandle = MonitorControlHandle;

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

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

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

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

impl fdomain_client::fidl::ProtocolMarker for RegistrarMarker {
    type Proxy = RegistrarProxy;
    type RequestStream = RegistrarRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.fuzzer.Registrar";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for RegistrarMarker {}

pub trait RegistrarProxyInterface: Send + Sync {
    type RegisterResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#register(
        &self,
        fuzzer_url: &str,
        provider: fdomain_client::fidl::ClientEnd<ControllerProviderMarker>,
    ) -> Self::RegisterResponseFut;
}

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

impl fdomain_client::fidl::Proxy for RegistrarProxy {
    type Protocol = RegistrarMarker;

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

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

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

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

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

    /// Adds a `ControllerProvider`. This should be called by the fuzzer itself,
    /// using the channel provided by the `fuzz_test_runner`, and in response to
    /// being started by the `fuzz_manager`.
    ///
    /// The registry will close the channel to the fuzzer on error, on a
    ///  corresponding call to `Registry.Disconnect`, or on exit. The fuzzer
    /// should exit when the channel closes.
    ///
    /// + request `fuzzer_url` the package URL for the fuzzer.
    /// + request `provider` the connection to a `ControllerProvider`.
    pub fn r#register(
        &self,
        mut fuzzer_url: &str,
        mut provider: fdomain_client::fidl::ClientEnd<ControllerProviderMarker>,
    ) -> fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect> {
        RegistrarProxyInterface::r#register(self, fuzzer_url, provider)
    }
}

impl RegistrarProxyInterface for RegistrarProxy {
    type RegisterResponseFut =
        fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect>;
    fn r#register(
        &self,
        mut fuzzer_url: &str,
        mut provider: fdomain_client::fidl::ClientEnd<ControllerProviderMarker>,
    ) -> Self::RegisterResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fdomain_client::fidl::FDomainResourceDialect,
                0x1716ac38e74b2840,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<RegistrarRegisterRequest, ()>(
            (fuzzer_url, provider),
            0x1716ac38e74b2840,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for RegistrarRequestStream {
    type Protocol = RegistrarMarker;
    type ControlHandle = RegistrarControlHandle;

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x1716ac38e74b2840 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RegistrarRegisterRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<RegistrarRegisterRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RegistrarControlHandle { inner: this.inner.clone() };
                        Ok(RegistrarRequest::Register {
                            fuzzer_url: req.fuzzer_url,
                            provider: req.provider,

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

/// Entry point for the `fuzz_test_runner`. It uses this protocol to transfer
/// one end of a channel it creates to the `fuzz_manager`. The other end is
/// passed as a startup handle to the fuzzer component itself, which is used to
/// provide `Controller`s on request.
#[derive(Debug)]
pub enum RegistrarRequest {
    /// Adds a `ControllerProvider`. This should be called by the fuzzer itself,
    /// using the channel provided by the `fuzz_test_runner`, and in response to
    /// being started by the `fuzz_manager`.
    ///
    /// The registry will close the channel to the fuzzer on error, on a
    ///  corresponding call to `Registry.Disconnect`, or on exit. The fuzzer
    /// should exit when the channel closes.
    ///
    /// + request `fuzzer_url` the package URL for the fuzzer.
    /// + request `provider` the connection to a `ControllerProvider`.
    Register {
        fuzzer_url: String,
        provider: fdomain_client::fidl::ClientEnd<ControllerProviderMarker>,
        responder: RegistrarRegisterResponder,
    },
}

impl RegistrarRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_register(
        self,
    ) -> Option<(
        String,
        fdomain_client::fidl::ClientEnd<ControllerProviderMarker>,
        RegistrarRegisterResponder,
    )> {
        if let RegistrarRequest::Register { fuzzer_url, provider, responder } = self {
            Some((fuzzer_url, provider, responder))
        } else {
            None
        }
    }

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

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

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

impl fdomain_client::fidl::ControlHandle for RegistrarControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

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

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fdomain_client::OnFDomainSignals {
        self.inner.channel().on_closed()
    }
}

impl RegistrarControlHandle {}

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

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

impl fdomain_client::fidl::Responder for RegistrarRegisterResponder {
    type ControlHandle = RegistrarControlHandle;

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

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

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

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

impl fdomain_client::fidl::ProtocolMarker for RegistryMarker {
    type Proxy = RegistryProxy;
    type RequestStream = RegistryRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.fuzzer.Registry";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for RegistryMarker {}
pub type RegistryConnectResult = Result<(), i32>;
pub type RegistryDisconnectResult = Result<(), i32>;

pub trait RegistryProxyInterface: Send + Sync {
    type ConnectResponseFut: std::future::Future<Output = Result<RegistryConnectResult, fidl::Error>>
        + Send;
    fn r#connect(
        &self,
        fuzzer_url: &str,
        controller: fdomain_client::fidl::ServerEnd<ControllerMarker>,
        timeout: i64,
    ) -> Self::ConnectResponseFut;
    type DisconnectResponseFut: std::future::Future<Output = Result<RegistryDisconnectResult, fidl::Error>>
        + Send;
    fn r#disconnect(&self, fuzzer_url: &str) -> Self::DisconnectResponseFut;
}

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

impl fdomain_client::fidl::Proxy for RegistryProxy {
    type Protocol = RegistryMarker;

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

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

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

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

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

    /// Connects the `Controller` to a registered fuzzer.
    ///
    /// Uses a `ControllerProvider` that has been `Register`ed with the given
    /// URL to connect. If the associated provider is not available, it assumes
    /// it is starting and blocks until the fuzzer calls `Registrar.Register`,
    /// or the given `timeout` elapses. At most one call to `Connect` will block
    /// in this manner at a time.
    ///
    /// + request `fuzzer_url` the package URL for the fuzzer.
    /// + request `provider` the connection to a `Controller` client.
    /// + request `tiemout` maximum duration to wait for a connection.
    /// * error one of the following:
    ///     * `ZX_ERR_TIMED_OUT` if the `timeout` elapses without the provider
    ///       becoming available.
    ///     * `ZX_ERR_SHOULD_WAIT` if already waiting for a fuzzer to start.
    pub fn r#connect(
        &self,
        mut fuzzer_url: &str,
        mut controller: fdomain_client::fidl::ServerEnd<ControllerMarker>,
        mut timeout: i64,
    ) -> fidl::client::QueryResponseFut<
        RegistryConnectResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        RegistryProxyInterface::r#connect(self, fuzzer_url, controller, timeout)
    }

    /// Removes the provider associated with the given URL from the registry and
    /// closes its channel. The associated fuzzer should exit upon channel
    /// closure.
    ///
    /// + request `fuzzer_url` the package URL for the fuzzer.
    /// * error `ZX_ERR_NOT_FOUND` if no such provider exists in the registry.
    pub fn r#disconnect(
        &self,
        mut fuzzer_url: &str,
    ) -> fidl::client::QueryResponseFut<
        RegistryDisconnectResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        RegistryProxyInterface::r#disconnect(self, fuzzer_url)
    }
}

impl RegistryProxyInterface for RegistryProxy {
    type ConnectResponseFut = fidl::client::QueryResponseFut<
        RegistryConnectResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#connect(
        &self,
        mut fuzzer_url: &str,
        mut controller: fdomain_client::fidl::ServerEnd<ControllerMarker>,
        mut timeout: i64,
    ) -> Self::ConnectResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RegistryConnectResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x5128cb31967a446f,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<RegistryConnectRequest, RegistryConnectResult>(
            (fuzzer_url, controller, timeout),
            0x5128cb31967a446f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for RegistryRequestStream {
    type Protocol = RegistryMarker;
    type ControlHandle = RegistryControlHandle;

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x5128cb31967a446f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RegistryConnectRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<RegistryConnectRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RegistryControlHandle { inner: this.inner.clone() };
                        Ok(RegistryRequest::Connect {
                            fuzzer_url: req.fuzzer_url,
                            controller: req.controller,
                            timeout: req.timeout,

                            responder: RegistryConnectResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7bb4b7591146d4cb => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RegistryDisconnectRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<RegistryDisconnectRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RegistryControlHandle { inner: this.inner.clone() };
                        Ok(RegistryRequest::Disconnect {
                            fuzzer_url: req.fuzzer_url,

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

/// Entry point for the `fuzz_manager`. It uses this protocol to wait for fuzz
/// tests started within the test runner framework to register a
/// `ControllerProvider`, and to stop those fuzzers upon request.
#[derive(Debug)]
pub enum RegistryRequest {
    /// Connects the `Controller` to a registered fuzzer.
    ///
    /// Uses a `ControllerProvider` that has been `Register`ed with the given
    /// URL to connect. If the associated provider is not available, it assumes
    /// it is starting and blocks until the fuzzer calls `Registrar.Register`,
    /// or the given `timeout` elapses. At most one call to `Connect` will block
    /// in this manner at a time.
    ///
    /// + request `fuzzer_url` the package URL for the fuzzer.
    /// + request `provider` the connection to a `Controller` client.
    /// + request `tiemout` maximum duration to wait for a connection.
    /// * error one of the following:
    ///     * `ZX_ERR_TIMED_OUT` if the `timeout` elapses without the provider
    ///       becoming available.
    ///     * `ZX_ERR_SHOULD_WAIT` if already waiting for a fuzzer to start.
    Connect {
        fuzzer_url: String,
        controller: fdomain_client::fidl::ServerEnd<ControllerMarker>,
        timeout: i64,
        responder: RegistryConnectResponder,
    },
    /// Removes the provider associated with the given URL from the registry and
    /// closes its channel. The associated fuzzer should exit upon channel
    /// closure.
    ///
    /// + request `fuzzer_url` the package URL for the fuzzer.
    /// * error `ZX_ERR_NOT_FOUND` if no such provider exists in the registry.
    Disconnect { fuzzer_url: String, responder: RegistryDisconnectResponder },
}

impl RegistryRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_connect(
        self,
    ) -> Option<(
        String,
        fdomain_client::fidl::ServerEnd<ControllerMarker>,
        i64,
        RegistryConnectResponder,
    )> {
        if let RegistryRequest::Connect { fuzzer_url, controller, timeout, responder } = self {
            Some((fuzzer_url, controller, timeout, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_disconnect(self) -> Option<(String, RegistryDisconnectResponder)> {
        if let RegistryRequest::Disconnect { fuzzer_url, responder } = self {
            Some((fuzzer_url, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            RegistryRequest::Connect { .. } => "connect",
            RegistryRequest::Disconnect { .. } => "disconnect",
        }
    }
}

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

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

impl fdomain_client::fidl::ControlHandle for RegistryControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

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

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fdomain_client::OnFDomainSignals {
        self.inner.channel().on_closed()
    }
}

impl RegistryControlHandle {}

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

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

impl fdomain_client::fidl::Responder for RegistryConnectResponder {
    type ControlHandle = RegistryControlHandle;

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

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

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

impl fdomain_client::fidl::Responder for RegistryDisconnectResponder {
    type ControlHandle = RegistryControlHandle;

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

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

impl fdomain_client::fidl::ProtocolMarker for TargetAdapterMarker {
    type Proxy = TargetAdapterProxy;
    type RequestStream = TargetAdapterRequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.fuzzer.TargetAdapter";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for TargetAdapterMarker {}

pub trait TargetAdapterProxyInterface: Send + Sync {
    type GetParametersResponseFut: std::future::Future<Output = Result<Vec<String>, fidl::Error>>
        + Send;
    fn r#get_parameters(&self) -> Self::GetParametersResponseFut;
    type ConnectResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#connect(
        &self,
        eventpair: fdomain_client::EventPair,
        test_input: fdomain_client::Vmo,
    ) -> Self::ConnectResponseFut;
}

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

impl fdomain_client::fidl::Proxy for TargetAdapterProxy {
    type Protocol = TargetAdapterMarker;

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

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

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

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

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

    /// Retrieves the target-specific fuzzer parameters, e.g. the package-
    /// relative location of seed corpora. These parameters are specific to
    /// individual fuzzers, and are used by both the fuzzing engine and the
    /// "test-engine" used to create fuzzer unit tests. For these reasons, it is
    /// most convenient for fuzzer authors to specify them as part of the
    /// (fuzzer-specific) target adapter's component manifest file, and have the
    /// engine and test-engine retrieve them via this method.
    ///
    /// - response `parameters` the command line parameters from a specific
    ///   fuzzer's component manifest.
    pub fn r#get_parameters(
        &self,
    ) -> fidl::client::QueryResponseFut<Vec<String>, fdomain_client::fidl::FDomainResourceDialect>
    {
        TargetAdapterProxyInterface::r#get_parameters(self)
    }

    /// Provides the eventpair used by driver and adapter to signal each other,
    /// and the shared VMO used to provide test inputs to the adapter. The VMO
    /// must have the `ZX_PROP_VMO_CONTENT_SIZE` property set.
    ///
    /// + request `eventpair` the eventpair used to signal when fuzzing runs
    ///   start and stop.
    /// + request `test_input` the shared VMO used by the engine to provide byte
    ///   sequences to test.
    pub fn r#connect(
        &self,
        mut eventpair: fdomain_client::EventPair,
        mut test_input: fdomain_client::Vmo,
    ) -> fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect> {
        TargetAdapterProxyInterface::r#connect(self, eventpair, test_input)
    }
}

impl TargetAdapterProxyInterface for TargetAdapterProxy {
    type GetParametersResponseFut =
        fidl::client::QueryResponseFut<Vec<String>, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#get_parameters(&self) -> Self::GetParametersResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<String>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                TargetAdapterGetParametersResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x5c7e40a47f753e3e,
            >(_buf?)?;
            Ok(_response.parameters)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<String>>(
            (),
            0x5c7e40a47f753e3e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ConnectResponseFut =
        fidl::client::QueryResponseFut<(), fdomain_client::fidl::FDomainResourceDialect>;
    fn r#connect(
        &self,
        mut eventpair: fdomain_client::EventPair,
        mut test_input: fdomain_client::Vmo,
    ) -> Self::ConnectResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fdomain_client::fidl::FDomainResourceDialect,
                0x7ea603a119866618,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<TargetAdapterConnectRequest, ()>(
            (eventpair, test_input),
            0x7ea603a119866618,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fdomain_client::fidl::RequestStream for TargetAdapterRequestStream {
    type Protocol = TargetAdapterMarker;
    type ControlHandle = TargetAdapterControlHandle;

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                0x5c7e40a47f753e3e => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = TargetAdapterControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(TargetAdapterRequest::GetParameters {
                        responder: TargetAdapterGetParametersResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x7ea603a119866618 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(TargetAdapterConnectRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<TargetAdapterConnectRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = TargetAdapterControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(TargetAdapterRequest::Connect {eventpair: req.eventpair,
test_input: req.test_input,

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

/// Maps test inputs to specific behaviors in the target code, e.g. by invoking
/// APIs, making FIDL calls. etc. The adapter includes the target-specific code
/// often referred to as the "fuzz target function".
///
/// See also:
///
/// * https://llvm.org/docs/LibFuzzer.html#fuzz-target
#[derive(Debug)]
pub enum TargetAdapterRequest {
    /// Retrieves the target-specific fuzzer parameters, e.g. the package-
    /// relative location of seed corpora. These parameters are specific to
    /// individual fuzzers, and are used by both the fuzzing engine and the
    /// "test-engine" used to create fuzzer unit tests. For these reasons, it is
    /// most convenient for fuzzer authors to specify them as part of the
    /// (fuzzer-specific) target adapter's component manifest file, and have the
    /// engine and test-engine retrieve them via this method.
    ///
    /// - response `parameters` the command line parameters from a specific
    ///   fuzzer's component manifest.
    GetParameters { responder: TargetAdapterGetParametersResponder },
    /// Provides the eventpair used by driver and adapter to signal each other,
    /// and the shared VMO used to provide test inputs to the adapter. The VMO
    /// must have the `ZX_PROP_VMO_CONTENT_SIZE` property set.
    ///
    /// + request `eventpair` the eventpair used to signal when fuzzing runs
    ///   start and stop.
    /// + request `test_input` the shared VMO used by the engine to provide byte
    ///   sequences to test.
    Connect {
        eventpair: fdomain_client::EventPair,
        test_input: fdomain_client::Vmo,
        responder: TargetAdapterConnectResponder,
    },
}

impl TargetAdapterRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_parameters(self) -> Option<(TargetAdapterGetParametersResponder)> {
        if let TargetAdapterRequest::GetParameters { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_connect(
        self,
    ) -> Option<(fdomain_client::EventPair, fdomain_client::Vmo, TargetAdapterConnectResponder)>
    {
        if let TargetAdapterRequest::Connect { eventpair, test_input, responder } = self {
            Some((eventpair, test_input, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            TargetAdapterRequest::GetParameters { .. } => "get_parameters",
            TargetAdapterRequest::Connect { .. } => "connect",
        }
    }
}

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

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

impl fdomain_client::fidl::ControlHandle for TargetAdapterControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

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

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fdomain_client::OnFDomainSignals {
        self.inner.channel().on_closed()
    }
}

impl TargetAdapterControlHandle {}

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

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

impl fdomain_client::fidl::Responder for TargetAdapterGetParametersResponder {
    type ControlHandle = TargetAdapterControlHandle;

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

    fn send_raw(&self, mut parameters: &[String]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<TargetAdapterGetParametersResponse>(
            (parameters,),
            self.tx_id,
            0x5c7e40a47f753e3e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

impl fdomain_client::fidl::Responder for TargetAdapterConnectResponder {
    type ControlHandle = TargetAdapterControlHandle;

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

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

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

mod internal {
    use super::*;

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

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for ControllerAddMonitorRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                monitor: fidl::new_empty!(
                    fidl::encoding::Endpoint<fdomain_client::fidl::ClientEnd<MonitorMarker>>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for ControllerAddToCorpusRequest {
        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 ControllerAddToCorpusRequest {
        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<
            ControllerAddToCorpusRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut ControllerAddToCorpusRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ControllerAddToCorpusRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                ControllerAddToCorpusRequest,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (
                    <Corpus as fidl::encoding::ValueTypeMarker>::borrow(&self.corpus),
                    <Input as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.input),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<Corpus, fdomain_client::fidl::FDomainResourceDialect>,
        T1: fidl::encoding::Encode<Input, fdomain_client::fidl::FDomainResourceDialect>,
    >
        fidl::encoding::Encode<
            ControllerAddToCorpusRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ControllerAddToCorpusRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for ControllerAddToCorpusRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                corpus: fidl::new_empty!(Corpus, fdomain_client::fidl::FDomainResourceDialect),
                input: fidl::new_empty!(Input, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffffffffff00u64;
            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!(
                Corpus,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.corpus,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                Input,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.input,
                decoder,
                offset + 8,
                _depth
            )?;
            Ok(())
        }
    }

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

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for ControllerCleanseRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                test_input: fidl::new_empty!(Input, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

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

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

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for ControllerMinimizeRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                test_input: fidl::new_empty!(Input, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

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

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

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for ControllerProviderConnectRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                controller: fidl::new_empty!(
                    fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<ControllerMarker>>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            ControllerReadCorpusRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut ControllerReadCorpusRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ControllerReadCorpusRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ControllerReadCorpusRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <Corpus as fidl::encoding::ValueTypeMarker>::borrow(&self.corpus),
                    <fidl::encoding::Endpoint<fdomain_client::fidl::ClientEnd<CorpusReaderMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.corpus_reader),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<Corpus, fdomain_client::fidl::FDomainResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fdomain_client::fidl::ClientEnd<CorpusReaderMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            ControllerReadCorpusRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ControllerReadCorpusRequest>(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 u32).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for ControllerReadCorpusRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                corpus: fidl::new_empty!(Corpus, fdomain_client::fidl::FDomainResourceDialect),
                corpus_reader: fidl::new_empty!(
                    fidl::encoding::Endpoint<fdomain_client::fidl::ClientEnd<CorpusReaderMarker>>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
            let padval = unsafe { (ptr as *const u32).read_unaligned() };
            let mask = 0xffffff00u32;
            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!(
                Corpus,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.corpus,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fdomain_client::fidl::ClientEnd<CorpusReaderMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.corpus_reader,
                decoder,
                offset + 4,
                _depth
            )?;
            Ok(())
        }
    }

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

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for ControllerReadDictionaryResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                dictionary: fidl::new_empty!(Input, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

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

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

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for ControllerTryOneRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                test_input: fidl::new_empty!(Input, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

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

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

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for ControllerWatchArtifactResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                artifact: fidl::new_empty!(Artifact, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

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

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

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for ControllerWriteDictionaryRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                dictionary: fidl::new_empty!(Input, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

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

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

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for CorpusReaderNextRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                test_input: fidl::new_empty!(Input, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for CoverageData {
        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 CoverageData {
        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<CoverageData, fdomain_client::fidl::FDomainResourceDialect>
        for &mut CoverageData
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CoverageData>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<CoverageData, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.target_id),
                    <Data as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.data),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<u64, fdomain_client::fidl::FDomainResourceDialect>,
        T1: fidl::encoding::Encode<Data, fdomain_client::fidl::FDomainResourceDialect>,
    > fidl::encoding::Encode<CoverageData, fdomain_client::fidl::FDomainResourceDialect>
        for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CoverageData>(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 + 8, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect> for CoverageData {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                target_id: fidl::new_empty!(u64, fdomain_client::fidl::FDomainResourceDialect),
                data: fidl::new_empty!(Data, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

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

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

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

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            CoverageDataCollectorInitializeRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut CoverageDataCollectorInitializeRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CoverageDataCollectorInitializeRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                CoverageDataCollectorInitializeRequest,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (
                    <fidl::encoding::HandleType<
                        fdomain_client::EventPair,
                        { fidl::ObjectType::EVENTPAIR.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.eventpair
                    ),
                    <fidl::encoding::HandleType<
                        fdomain_client::Process,
                        { fidl::ObjectType::PROCESS.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.process
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fdomain_client::EventPair,
                    { fidl::ObjectType::EVENTPAIR.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fdomain_client::Process,
                    { fidl::ObjectType::PROCESS.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            CoverageDataCollectorInitializeRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CoverageDataCollectorInitializeRequest>(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)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for CoverageDataCollectorInitializeRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                eventpair: fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect),
                process: fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Process, { fidl::ObjectType::PROCESS.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

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

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

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for CoverageDataProviderWatchCoverageDataResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                coverage_data: fidl::new_empty!(fidl::encoding::Vector<CoverageData, 4096>, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for Input {
        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 Input {
        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<Input, fdomain_client::fidl::FDomainResourceDialect>
        for &mut Input
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Input>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<Input, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fidl::encoding::HandleType<
                        fdomain_client::Socket,
                        { fidl::ObjectType::SOCKET.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.socket
                    ),
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.size),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fdomain_client::Socket,
                    { fidl::ObjectType::SOCKET.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<u64, fdomain_client::fidl::FDomainResourceDialect>,
    > fidl::encoding::Encode<Input, fdomain_client::fidl::FDomainResourceDialect> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Input>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect> for Input {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                socket: fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect),
                size: fidl::new_empty!(u64, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<InstrumentedProcess, fdomain_client::fidl::FDomainResourceDialect>
        for &mut InstrumentedProcess
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<InstrumentedProcess>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                InstrumentedProcess,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (
                    <fidl::encoding::HandleType<
                        fdomain_client::EventPair,
                        { fidl::ObjectType::EVENTPAIR.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.eventpair
                    ),
                    <fidl::encoding::HandleType<
                        fdomain_client::Process,
                        { fidl::ObjectType::PROCESS.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.process
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fdomain_client::EventPair,
                    { fidl::ObjectType::EVENTPAIR.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fdomain_client::Process,
                    { fidl::ObjectType::PROCESS.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    > fidl::encoding::Encode<InstrumentedProcess, fdomain_client::fidl::FDomainResourceDialect>
        for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<InstrumentedProcess>(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)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for InstrumentedProcess
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                eventpair: fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect),
                process: fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Process, { fidl::ObjectType::PROCESS.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for ManagerConnectRequest {
        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 ManagerConnectRequest {
        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<ManagerConnectRequest, fdomain_client::fidl::FDomainResourceDialect>
        for &mut ManagerConnectRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ManagerConnectRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ManagerConnectRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(&self.fuzzer_url),
                    <fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<ControllerMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.controller),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::BoundedString<4096>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<ControllerMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<ManagerConnectRequest, fdomain_client::fidl::FDomainResourceDialect>
        for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ManagerConnectRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for ManagerConnectRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                fuzzer_url: fidl::new_empty!(
                    fidl::encoding::BoundedString<4096>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                controller: fidl::new_empty!(
                    fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<ControllerMarker>>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for ManagerGetOutputRequest {
        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 ManagerGetOutputRequest {
        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<
            ManagerGetOutputRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut ManagerGetOutputRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ManagerGetOutputRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ManagerGetOutputRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(&self.fuzzer_url),
                    <TestOutput as fidl::encoding::ValueTypeMarker>::borrow(&self.output),
                    <fidl::encoding::HandleType<fdomain_client::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.socket),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::BoundedString<4096>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<TestOutput, fdomain_client::fidl::FDomainResourceDialect>,
        T2: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fdomain_client::Socket,
                    { fidl::ObjectType::SOCKET.into_raw() },
                    2147483648,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            ManagerGetOutputRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ManagerGetOutputRequest>(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 + 16, depth)?;
            self.2.encode(encoder, offset + 20, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for ManagerGetOutputRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                fuzzer_url: fidl::new_empty!(
                    fidl::encoding::BoundedString<4096>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                output: fidl::new_empty!(TestOutput, fdomain_client::fidl::FDomainResourceDialect),
                socket: fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for RegistrarRegisterRequest {
        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 RegistrarRegisterRequest {
        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<
            RegistrarRegisterRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut RegistrarRegisterRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RegistrarRegisterRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RegistrarRegisterRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(&self.fuzzer_url),
                    <fidl::encoding::Endpoint<fdomain_client::fidl::ClientEnd<ControllerProviderMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.provider),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::BoundedString<4096>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fdomain_client::fidl::ClientEnd<ControllerProviderMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            RegistrarRegisterRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RegistrarRegisterRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for RegistrarRegisterRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                fuzzer_url: fidl::new_empty!(
                    fidl::encoding::BoundedString<4096>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                provider: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fdomain_client::fidl::ClientEnd<ControllerProviderMarker>,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<RegistryConnectRequest, fdomain_client::fidl::FDomainResourceDialect>
        for &mut RegistryConnectRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RegistryConnectRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RegistryConnectRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(&self.fuzzer_url),
                    <fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<ControllerMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.controller),
                    <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.timeout),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::BoundedString<4096>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<ControllerMarker>>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T2: fidl::encoding::Encode<i64, fdomain_client::fidl::FDomainResourceDialect>,
    >
        fidl::encoding::Encode<RegistryConnectRequest, fdomain_client::fidl::FDomainResourceDialect>
        for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RegistryConnectRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            self.2.encode(encoder, offset + 24, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for RegistryConnectRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                fuzzer_url: fidl::new_empty!(
                    fidl::encoding::BoundedString<4096>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                controller: fidl::new_empty!(
                    fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<ControllerMarker>>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                timeout: fidl::new_empty!(i64, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

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

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

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

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

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

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for TargetAdapterConnectRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                eventpair: fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect),
                test_input: fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

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

    impl Artifact {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.error {
                return 3;
            }
            if let Some(_) = self.input {
                return 2;
            }
            if let Some(_) = self.result {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for Artifact {
        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 Artifact {
        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<Artifact, fdomain_client::fidl::FDomainResourceDialect>
        for &mut Artifact
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Artifact>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                Result_,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.result.as_ref().map(<Result_ as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 2 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (2 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                Input,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.input
                    .as_mut()
                    .map(<Input as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 3 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (3 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                i32,
                fdomain_client::fidl::FDomainResourceDialect,
            >(
                self.error.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect> for Artifact {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <Result_ as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.result.get_or_insert_with(|| {
                    fidl::new_empty!(Result_, fdomain_client::fidl::FDomainResourceDialect)
                });
                fidl::decode!(
                    Result_,
                    fdomain_client::fidl::FDomainResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 2 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <Input as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.input.get_or_insert_with(|| {
                    fidl::new_empty!(Input, fdomain_client::fidl::FDomainResourceDialect)
                });
                fidl::decode!(
                    Input,
                    fdomain_client::fidl::FDomainResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 3 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.error.get_or_insert_with(|| {
                    fidl::new_empty!(i32, fdomain_client::fidl::FDomainResourceDialect)
                });
                fidl::decode!(
                    i32,
                    fdomain_client::fidl::FDomainResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for Data {
        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 Data {
        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<Data, fdomain_client::fidl::FDomainResourceDialect>
        for &mut Data
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Data>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
                Data::Instrumented(ref mut val) => fidl::encoding::encode_in_envelope::<
                    InstrumentedProcess,
                    fdomain_client::fidl::FDomainResourceDialect,
                >(
                    <InstrumentedProcess as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        val,
                    ),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                Data::Inline8bitCounters(ref mut val) => fidl::encoding::encode_in_envelope::<
                    fidl::encoding::HandleType<
                        fdomain_client::Vmo,
                        { fidl::ObjectType::VMO.into_raw() },
                        2147483648,
                    >,
                    fdomain_client::fidl::FDomainResourceDialect,
                >(
                    <fidl::encoding::HandleType<
                        fdomain_client::Vmo,
                        { fidl::ObjectType::VMO.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        val
                    ),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                Data::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
            }
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect> for Data {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::__SourceBreaking { unknown_ordinal: 0 }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            #[allow(unused_variables)]
            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            let (ordinal, inlined, num_bytes, num_handles) =
                fidl::encoding::decode_union_inline_portion(decoder, offset)?;

            let member_inline_size = match ordinal {
                1 => <InstrumentedProcess as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context,
                ),
                2 => <fidl::encoding::HandleType<
                    fdomain_client::Vmo,
                    { fidl::ObjectType::VMO.into_raw() },
                    2147483648,
                > as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                0 => return Err(fidl::Error::UnknownUnionTag),
                _ => num_bytes as usize,
            };

            if inlined != (member_inline_size <= 4) {
                return Err(fidl::Error::InvalidInlineBitInEnvelope);
            }
            let _inner_offset;
            if inlined {
                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
                _inner_offset = offset + 8;
            } else {
                depth.increment()?;
                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
            }
            match ordinal {
                1 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Data::Instrumented(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Data::Instrumented(fidl::new_empty!(
                            InstrumentedProcess,
                            fdomain_client::fidl::FDomainResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Data::Instrumented(ref mut val) = self {
                        fidl::decode!(
                            InstrumentedProcess,
                            fdomain_client::fidl::FDomainResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                2 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Data::Inline8bitCounters(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Data::Inline8bitCounters(
                            fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Data::Inline8bitCounters(ref mut val) = self {
                        fidl::decode!(fidl::encoding::HandleType<fdomain_client::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fdomain_client::fidl::FDomainResourceDialect, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                #[allow(deprecated)]
                ordinal => {
                    for _ in 0..num_handles {
                        decoder.drop_next_handle()?;
                    }
                    *self = Data::__SourceBreaking { unknown_ordinal: ordinal };
                }
            }
            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
                return Err(fidl::Error::InvalidNumBytesInEnvelope);
            }
            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
            }
            Ok(())
        }
    }
}