fidl_fuchsia_fuzzer/

fidl_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 fidl::client::QueryResponseFut;
use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
use fidl::endpoints::{ControlHandle as _, Responder as _};
use futures::future::{self, MaybeDone, TryFutureExt};
use zx_status;

/// Marker indicating the last message in a diagnostic output stream.
///
/// In addition to an `Artifact`, long-running workflows may also produce the
/// standard output, standard error, and system logs. These fuzzer output
/// streams are provided by `fuchsia.test_manager/RunBuilder` and have no
/// guaranteed order with respect to FIDL responses. As a result, the streams
/// need to include an "in-band" signal that indicates when they are complete
/// for a particular workflow. Clients processing the fuzzer output may use this
/// marker to synchronize the streams and the FIDL response for `GetArtifact`.
///
/// The string is intentionally somewhat long to mitigate the likelihood of it
/// being emitted by the code under test.
pub const DONE_MARKER: &str =
    "DONE: A long-running `fuchsia.fuzzer.Controller` workflow is complete.";

/// Command line flag requesting fuzzing to be performed.
///
/// This flag is passed by the `fuzz_manager` to the `test_manager` when
/// starting fuzzers. Since the fuzzers are run as part of the Test Runner
/// Framework, they can be started by normal test workflows, e.g. `fx test`. The
/// presence of this flag indicates the fuzzer is being started to perform
/// fuzzing; in its absence the fuzzer should simply execute a bounded number of
/// inputs as a test.
pub const FUZZ_MODE: &str = "--fuzz";

/// Maximum length of a vector of CoverageData structs.
///
/// This value matches the maximum number of LLVM modules libFuzzer can track.
pub const MAX_COVERAGE_DATA: u64 = 4096;

pub const MAX_PARAMETERS: u16 = 128;

pub const MAX_PARAMETER_LEN: u16 = 256;

/// The maximum number of processes for which stats will be returned via
/// `Status`.
pub const MAX_PROCESS_STATS: u16 = 256;

/// Maximum length of a sanitizer options environment variable name.
///
/// `sanitizer_options.name` must be something like "...SAN_OPTIONS". The
/// longest name currently supported on Fuchsia is "UBSAN_OPTIONS". The longest
/// currently supported on any platform is "HWASAN_OPTIONS".
pub const MAX_SANITIZER_OPTIONS_NAME_SIZE: u16 = 32;

/// Maximum length of a sanitizer options environment variable value.
///
/// `sanitizer_options.value` is a concatenation of "<key>=<value>" pairs
/// delimited by ':'. AddressSanitizer currently has the most flags, with ~40
/// sanitizer specific ones and ~70 common ones. Most of these are either
/// boolean values or short integers. The only long types of flags are paths,
/// but none these of these are supported on Fuchsia.
pub const MAX_SANITIZER_OPTIONS_VALUE_SIZE: u16 = 8192;

bitflags! {
    /// Specifies how a fuzzing engine should configure output streams.
    ///
    /// Flags may be combined, e.g. `CLOSE_STDOUT | CLOSE_STDERR`. Support for each
    /// flag is engine-specific. Specifying an unsupported output mode flag may
    /// cause `Controller.Configure` to return `ZX_ERR_NOT_SUPPORTED`.
    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct OutputFlags: u32 {
        /// Suppress standard output from the engine process. This is analogous to
        /// libFuzzer's `-close_fd_mask=1`.
        const CLOSE_STDOUT = 1;
        /// Suppress standard error from the engine process. Use with care: this may
        /// remove diagnostic output from the target code (e.g. messages on assert
        /// failure). This is analogous to libFuzzer's `-close_fd_mask=2`.
        const CLOSE_STDERR = 2;
        /// Produce more verbose output from the fuzzer engine. The exact meaning of
        /// "more verbose" is engine-specific. This is analogous to libFuzzer's
        /// `-verbosity=2`.
        const VERBOSE = 4;
        /// Produce libFuzzer-style output on standard error. This facilitates
        /// integration with systems like ClusterFuzz.
        /// See https://llvm.org/docs/LibFuzzer.html#output for example output.
        const LIBFUZZER = 8;
    }
}

impl OutputFlags {
    #[deprecated = "Strict bits should not use `has_unknown_bits`"]
    #[inline(always)]
    pub fn has_unknown_bits(&self) -> bool {
        false
    }

    #[deprecated = "Strict bits should not use `get_unknown_bits`"]
    #[inline(always)]
    pub fn get_unknown_bits(&self) -> u32 {
        0
    }
}

/// See |Controller.GetCorpusWriter| and |Controller.GetCorpusReader|.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum Corpus {
    /// Indicates a set of fixed, immutable inputs typically provided at
    /// start-up. These inputs are never discarded when merging.
    Seed,
    /// Indicates a set of inputs generated by the fuzzer. These may be modified
    /// and/or discarded when merging and minimizing the corpus.
    Live,
    #[doc(hidden)]
    __SourceBreaking { unknown_ordinal: u8 },
}

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

impl Corpus {
    #[inline]
    pub fn from_primitive(prim: u8) -> Option<Self> {
        match prim {
            1 => Some(Self::Seed),
            2 => Some(Self::Live),
            _ => None,
        }
    }

    #[inline]
    pub fn from_primitive_allow_unknown(prim: u8) -> Self {
        match prim {
            1 => Self::Seed,
            2 => Self::Live,
            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
        }
    }

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

    #[inline]
    pub const fn into_primitive(self) -> u8 {
        match self {
            Self::Seed => 1,
            Self::Live => 2,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

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

/// Indicates the result of a long-running fuzzing workflow.
///
/// Fuzzers have several "long-running" workflows; that is, the fuzzer may
/// perform actions for an indefinite period of time. Fuzzing itself is the most
/// notable example, as the fuzzing engine may continuously generate new inputs
/// until an error is found. This workflow is represented by the `Fuzz` method
/// below. Other long-running workflows include `TryOne`, `Cleanse`, `Minimize`
/// and `Merge`.
///
/// These workflows continue executing after their associated call returns. Only
/// one workflow at a time may be executing. Callers can use `AddMonitor` to
/// monitor the status of the workflow, and `GetArtifact` to retrieve the
/// `Result` and optionally associated `Input` when it completes.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum Result_ {
    /// The associated input did not cause any errors to be detected when tried.
    NoErrors,
    /// Trying the associated input triggered a memory allocation by an
    /// instrumented process that exceeded the configured limit.  Some fuzzing
    /// engines, such as libFuzzer, may not distinguish between this result and
    /// `OOM`. To differentiate,  examine the fuzzer output.
    BadMalloc,
    /// Trying the associated input triggered an exception in an instrumented
    /// process.
    Crash,
    /// Trying the associated input triggered an error in an instrumented
    /// process that was detected by a sanitizer runtime.
    Death,
    /// Trying the associated input caused an instrumented process to exit
    /// unexpectedly. Some fuzzing engines such as libFuzzer may combine this
    /// result with `CRASH`. To differentiate, examine the fuzzer output.
    Exit,
    /// Trying the associated input triggered a memory leak in an instrumented
    /// process.
    Leak,
    /// Trying the associated input caused an instrumented process's memory
    /// usage to exceed the configured limit.
    Oom,
    /// Trying the associated input took longer than the configured limit.
    Timeout,
    /// The associated input was produced by finding the shortest input that
    /// produces the same error as an original input. See `Minimize`.
    Minimized,
    /// The associated input was produced by replacing bytes in an original
    /// input with PII-free values while preserving the error produced. See
    /// `Cleanse`.
    Cleansed,
    /// The fuzzer corpus has been compacted to only include the shortest inputs
    /// that preserve overall coverage. This workflow does not have an
    /// associated input. See `Merge`.
    Merged,
    #[doc(hidden)]
    __SourceBreaking { unknown_ordinal: u32 },
}

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

impl Result_ {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            1 => Some(Self::NoErrors),
            2 => Some(Self::BadMalloc),
            3 => Some(Self::Crash),
            4 => Some(Self::Death),
            5 => Some(Self::Exit),
            6 => Some(Self::Leak),
            7 => Some(Self::Oom),
            8 => Some(Self::Timeout),
            9 => Some(Self::Minimized),
            10 => Some(Self::Cleansed),
            11 => Some(Self::Merged),
            _ => None,
        }
    }

    #[inline]
    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
        match prim {
            1 => Self::NoErrors,
            2 => Self::BadMalloc,
            3 => Self::Crash,
            4 => Self::Death,
            5 => Self::Exit,
            6 => Self::Leak,
            7 => Self::Oom,
            8 => Self::Timeout,
            9 => Self::Minimized,
            10 => Self::Cleansed,
            11 => Self::Merged,
            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
        }
    }

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

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        match self {
            Self::NoErrors => 1,
            Self::BadMalloc => 2,
            Self::Crash => 3,
            Self::Death => 4,
            Self::Exit => 5,
            Self::Leak => 6,
            Self::Oom => 7,
            Self::Timeout => 8,
            Self::Minimized => 9,
            Self::Cleansed => 10,
            Self::Merged => 11,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

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

/// Represents types of fuzzer output.
///
/// These correspond to the subset of the `fuchsia.test_manager/Artifact`s that
/// `fuzz_manager` can forward. The name "artifact" is avoided due to its
/// distinct meaning for fuzzers; namely, `fuchsia.fuzzer.Artifact`.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum TestOutput {
    /// Standard output from fuzzer.
    Stdout,
    /// Standard error from fuzzer.
    Stderr,
    /// System logs from fuzzer.
    Syslog,
    #[doc(hidden)]
    __SourceBreaking { unknown_ordinal: u32 },
}

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

impl TestOutput {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            1 => Some(Self::Stdout),
            2 => Some(Self::Stderr),
            3 => Some(Self::Syslog),
            _ => None,
        }
    }

    #[inline]
    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
        match prim {
            1 => Self::Stdout,
            2 => Self::Stderr,
            3 => Self::Syslog,
            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
        }
    }

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

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        match self {
            Self::Stdout => 1,
            Self::Stderr => 2,
            Self::Syslog => 3,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

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

/// See `Controller.Monitor`. Used to indicate why an update was sent.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum UpdateReason {
    /// Represents an otherwise unspecified update. Useful when integrating
    /// other engines as runners, e.g. libFuzzer.
    Misc,
    /// A fuzzing action is starting. See, e.g. `Controller.Fuzz`,
    /// `Controller.Merge`, etc.
    Init,
    /// An input produced new feedback.
    New,
    /// Periodic status update, configured with `Options.pulse_interval`.
    Pulse,
    /// A shorter input for some particular feedback has been found.
    Reduce,
    /// A fuzzing action is complete.
    Done,
    #[doc(hidden)]
    __SourceBreaking { unknown_ordinal: u8 },
}

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

impl UpdateReason {
    #[inline]
    pub fn from_primitive(prim: u8) -> Option<Self> {
        match prim {
            1 => Some(Self::Misc),
            2 => Some(Self::Init),
            3 => Some(Self::New),
            4 => Some(Self::Pulse),
            5 => Some(Self::Reduce),
            6 => Some(Self::Done),
            _ => None,
        }
    }

    #[inline]
    pub fn from_primitive_allow_unknown(prim: u8) -> Self {
        match prim {
            1 => Self::Misc,
            2 => Self::Init,
            3 => Self::New,
            4 => Self::Pulse,
            5 => Self::Reduce,
            6 => Self::Done,
            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
        }
    }

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

    #[inline]
    pub const fn into_primitive(self) -> u8 {
        match self {
            Self::Misc => 1,
            Self::Init => 2,
            Self::New => 3,
            Self::Pulse => 4,
            Self::Reduce => 5,
            Self::Done => 6,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

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

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

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

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

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

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

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

#[derive(Clone, Debug, PartialEq)]
pub struct ControllerConfigureRequest {
    pub options: Options,
}

impl fidl::Persistable for ControllerConfigureRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct ControllerGetOptionsResponse {
    pub options: Options,
}

impl fidl::Persistable for ControllerGetOptionsResponse {}

#[derive(Clone, Debug, PartialEq)]
pub struct ControllerGetStatusResponse {
    pub status: Status,
}

impl fidl::Persistable for ControllerGetStatusResponse {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct CorpusReaderNextResponse {
    pub result: i32,
}

impl fidl::Persistable for CorpusReaderNextResponse {}

/// 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<fidl::encoding::DefaultFuchsiaResourceDialect> for CoverageData {}

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

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

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

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

#[derive(Clone, Debug, PartialEq)]
pub struct CoverageDataCollectorInitializeResponse {
    pub options: Options,
}

impl fidl::Persistable for CoverageDataCollectorInitializeResponse {}

#[derive(Clone, Debug, PartialEq)]
pub struct CoverageDataProviderSetOptionsRequest {
    pub options: Options,
}

impl fidl::Persistable for CoverageDataProviderSetOptionsRequest {}

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

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    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: fidl::Socket,
    /// The total amount of data to be transferred.
    pub size: u64,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> 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: fidl::EventPair,
    pub process: fidl::Process,
}

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

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

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

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

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

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ManagerStopRequest {
    pub fuzzer_url: String,
}

impl fidl::Persistable for ManagerStopRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct MonitorUpdateRequest {
    pub reason: UpdateReason,
    pub status: Status,
}

impl fidl::Persistable for MonitorUpdateRequest {}

/// Details about an instrumented process.
///
/// See also:
///
/// * https://fuchsia.dev/fuchsia-src/reference/syscalls/object_get_info#zx_info_task_stats
/// * https://fuchsia.dev/fuchsia-src/reference/syscalls/object_get_info#zx_info_task_runtime
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct ProcessStats {
    /// The kernel object identifier of the task.
    pub koid: u64,
    /// The total size of mapped memory ranges in this process.
    pub mem_mapped_bytes: u64,
    /// Committed memory that is only mapped into this process.
    pub mem_private_bytes: u64,
    /// Committed memory that is mapped into this and at least one other
    /// process.
    pub mem_shared_bytes: u64,
    /// Estimate of how much of |mem_shared_bytes| that this process owns.
    pub mem_scaled_shared_bytes: u64,
    /// The total amount of time this process was running on a CPU and not
    /// blocked.
    pub cpu_time: i64,
    /// The total amount of time this process was ready but not actually using a
    /// CPU.
    pub queue_time: i64,
    /// The total amount of time this process spent handling page faults.
    pub page_fault_time: i64,
    /// The total amount of time this process spent waiting on contended kernel
    /// locks.
    pub lock_contention_time: i64,
}

impl fidl::Persistable for ProcessStats {}

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

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

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

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

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RegistryDisconnectRequest {
    pub fuzzer_url: String,
}

impl fidl::Persistable for RegistryDisconnectRequest {}

/// Corresponds to sanitizer enviroment variables.
///
/// The options are ignored unless `name` must end in "...SAN_OPTIONS", e.g.
/// "ASAN_OPTIONS". `value` should be a ':'-delimited list of options, e.g.
/// "verbosity=1:malloc_context_size=20".
///
/// For more details, see the following:
///
/// * https://github.com/google/sanitizers/wiki/SanitizerCommonFlags
/// * https://github.com/google/sanitizers/wiki/AddressSanitizerFlags
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct SanitizerOptions {
    pub name: String,
    pub value: String,
}

impl fidl::Persistable for SanitizerOptions {}

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

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

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TargetAdapterGetParametersResponse {
    pub parameters: Vec<String>,
}

impl fidl::Persistable for TargetAdapterGetParametersResponse {}

/// 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<fidl::encoding::DefaultFuchsiaResourceDialect> for Artifact {}

/// See `fuchsia.fuzzer.Controller/Configure`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Options {
    /// Perform this many fuzzing runs, then exit normally. If unset (or zero),
    /// fuzz indefinitely.
    pub runs: Option<u32>,
    /// If non-zero, fuzz for this duration and then exit normally. If zero,
    /// fuzz indefinitely. Defaults to 0.
    pub max_total_time: Option<i64>,
    /// PRNG seed to use when generating inputs. The same seed for the same
    /// target should produce the same inputs. If zero, the current ticks will
    /// be used. Defaults to 0.
    pub seed: Option<u32>,
    /// If non-zero, limit the maximum size of a test input to this size, in
    /// bytes. Use 0 to disable the limit. Defaults to 1 MB.
    pub max_input_size: Option<u64>,
    /// Maximum number of consecutive mutations to apply to an input. Defaults
    /// to 5.
    pub mutation_depth: Option<u16>,
    /// If an AFL-style dictionary is supplied using
    /// `Controller.WriteDictionary`, include words up to this level. Defaults
    /// to 0, i.e. words without an explicit level.
    pub dictionary_level: Option<u16>,
    /// If true, treat instrumented process exits as fuzzing errors. Defaults to
    /// false.
    pub detect_exits: Option<bool>,
    /// If true, and ASan or LSan are available, try to detect memory leaks.
    /// Defaults to false. Leak detection can be expensive, so it is recommended
    /// to first develop a corpus that covers a reasonable amount of the code
    /// under test before attempting to detect leaks.
    pub detect_leaks: Option<bool>,
    /// If non-zero, any run that takes longer than this duration will raise a
    /// TIMEOUT error. Use 0 to disable the limit. Defaults to 20 minutes.
    pub run_limit: Option<i64>,
    /// If non-zero, any allocation over this size in bytes will raise a
    /// BAD_MALLOC error. Use 0 to disable the limit. Defaults to 2 GB.
    pub malloc_limit: Option<u64>,
    /// If non-zero, any process that uses more than this amount of memory in
    /// bytes will raise an OOM error. Use 0 to disable the limit. Defaults to
    /// 2 GB.
    pub oom_limit: Option<u64>,
    /// If non-zero, purge the sanitizer's allocator quarantine and reclaim
    /// memory periodically between runs after an interval of this many seconds.
    /// Use 0 to disable allocator purging. Defaults to 1 second.
    pub purge_interval: Option<i64>,
    /// Exit code used by the instrumented process if it encounters a bad
    /// allocation. Set this if the target already uses the default for another
    /// reason. Defaults to 2000.
    pub malloc_exitcode: Option<i32>,
    /// Exit code used by the instrumented process if it encounters a sanitizer
    /// error. Set this if the target already uses the default for another
    /// reason. Defaults to 2001.
    pub death_exitcode: Option<i32>,
    /// Exit code used by the instrumented process if it encounters a leak. Set
    /// this if the target already uses the default for another reason. Defaults
    /// to 2002.
    pub leak_exitcode: Option<i32>,
    /// Exit code used by the instrumented process if it exceeds the OOM limit.
    /// Set this if the target already uses the default for another reason.
    /// Defaults to 2003.
    pub oom_exitcode: Option<i32>,
    /// If non-zero, the engine will periodically update any added monitors
    /// after this duration. Defaults to 20 seconds.
    pub pulse_interval: Option<i64>,
    /// If true, allow a debugger like `zxdb` to be attached to an instrumented
    /// process. This may interfere with the engine's ability to detect
    /// exceptions and is not recommended when fuzzing. It can be useful when
    /// reproducing an error with a known error-causing input. Defaults to
    /// false.
    pub debug: Option<bool>,
    /// If true, include ClusterFuzz-compatible final statistics in the output
    /// of a call to `fuchsia.fuzzer.Controller/WatchArtifact`.
    pub print_final_stats: Option<bool>,
    /// If true, also use data flow traces as part of the fuzzing coverage data.
    /// See https://clang.llvm.org/docs/SanitizerCoverage.html#tracing-data-flow
    /// for more details.
    pub use_value_profile: Option<bool>,
    /// Sanitizer options. See `SanitizerOptions`.
    pub sanitizer_options: Option<SanitizerOptions>,
    /// Output flags. See `OutputFlags`.
    pub output_flags: Option<OutputFlags>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for Options {}

/// See `Controller.GetStatus`.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Status {
    /// True if the fuzzer is working on a commands, e.g. it is fuzzing.
    pub running: Option<bool>,
    /// Number of runs performed so far.
    pub runs: Option<u32>,
    /// Time spent so far.
    pub elapsed: Option<i64>,
    /// Number of program edges covered so far.
    pub covered_pcs: Option<u64>,
    /// Number of opaque features encountered so far.
    pub covered_features: Option<u64>,
    /// Number of inputs in the "live" corpus.
    pub corpus_num_inputs: Option<u64>,
    /// Total size of the inputs in the "live" corpus.
    pub corpus_total_size: Option<u64>,
    /// Information about the instrumented processes attached to the engine.
    pub process_stats: Option<Vec<ProcessStats>>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for Status {}

#[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(fidl::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<fidl::encoding::DefaultFuchsiaResourceDialect> for Data {}

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

impl fidl::endpoints::ProtocolMarker for ControllerMarker {
    type Proxy = ControllerProxy;
    type RequestStream = ControllerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ControllerSynchronousProxy;

    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: fidl::endpoints::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: fidl::endpoints::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)]
#[cfg(target_os = "fuchsia")]
pub struct ControllerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ControllerSynchronousProxy {
    type Proxy = ControllerProxy;
    type Protocol = ControllerMarker;

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

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

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

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

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

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

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ControllerConfigureResult, fidl::Error> {
        let _response = self.client.send_query::<
            ControllerConfigureRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (options,),
            0x35c8cba7fa3d32e4,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// 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, ___deadline: zx::MonotonicInstant) -> Result<Options, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, ControllerGetOptionsResponse>(
                (),
                0x683d93332504b9cd,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.options)
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ControllerAddToCorpusResult, fidl::Error> {
        let _response = self.client.send_query::<
            ControllerAddToCorpusRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (corpus, &mut input,),
            0x7bdf8336ab534cee,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// 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: fidl::endpoints::ClientEnd<CorpusReaderMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response =
            self.client.send_query::<ControllerReadCorpusRequest, fidl::encoding::EmptyPayload>(
                (corpus, corpus_reader),
                0x501279b430b34514,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ControllerWriteDictionaryResult, fidl::Error> {
        let _response = self.client.send_query::<
            ControllerWriteDictionaryRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (&mut dictionary,),
            0x4ecfc1274fe4a70b,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Returns the current dictionary as an Input, which may be empty.
    ///
    /// - response `dictionary` the current AFL-style dictionary.
    pub fn r#read_dictionary(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Input, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, ControllerReadDictionaryResponse>(
                (),
                0x1be6724c87b51c37,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.dictionary)
    }

    /// 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: fidl::endpoints::ClientEnd<MonitorMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response =
            self.client.send_query::<ControllerAddMonitorRequest, fidl::encoding::EmptyPayload>(
                (monitor,),
                0x2efbf7d3dc21438e,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ControllerFuzzResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (),
            0x62fe3684ea23af62,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ControllerTryOneResult, fidl::Error> {
        let _response = self.client.send_query::<
            ControllerTryOneRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (&mut test_input,),
            0x368dc762d8e16d46,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ControllerMinimizeResult, fidl::Error> {
        let _response = self.client.send_query::<
            ControllerMinimizeRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (&mut test_input,),
            0x105a242ee0552794,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ControllerCleanseResult, fidl::Error> {
        let _response = self.client.send_query::<
            ControllerCleanseRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (&mut test_input,),
            0x6d7892f62735f3e0,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ControllerMergeResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (),
            0x3614e5c39413b5eb,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Returns various fuzzing metrics, e.g. total coverage, speed, etc.
    ///
    /// - response `status` the current value of fuzzing metrics.
    pub fn r#get_status(&self, ___deadline: zx::MonotonicInstant) -> Result<Status, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, ControllerGetStatusResponse>(
                (),
                0x51db4975d93ce768,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.status)
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Artifact, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, ControllerWatchArtifactResponse>(
                (),
                0x6cfca3730944a414,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.artifact)
    }
}

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

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

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

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

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

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

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> 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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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: fidl::endpoints::ClientEnd<CorpusReaderMarker>,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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, fidl::encoding::DefaultFuchsiaResourceDialect> {
        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: fidl::endpoints::ClientEnd<MonitorMarker>,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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, fidl::encoding::DefaultFuchsiaResourceDialect> {
        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, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        ControllerProxyInterface::r#watch_artifact(self)
    }
}

impl ControllerProxyInterface for ControllerProxy {
    type ConfigureResponseFut = fidl::client::QueryResponseFut<
        ControllerConfigureResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#configure(&self, mut options: &Options) -> Self::ConfigureResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#get_options(&self) -> Self::GetOptionsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Options, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ControllerGetOptionsResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#add_to_corpus(
        &self,
        mut corpus: Corpus,
        mut input: Input,
    ) -> Self::AddToCorpusResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#read_corpus(
        &self,
        mut corpus: Corpus,
        mut corpus_reader: fidl::endpoints::ClientEnd<CorpusReaderMarker>,
    ) -> Self::ReadCorpusResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#write_dictionary(&self, mut dictionary: Input) -> Self::WriteDictionaryResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#read_dictionary(&self) -> Self::ReadDictionaryResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Input, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ControllerReadDictionaryResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#add_monitor(
        &self,
        mut monitor: fidl::endpoints::ClientEnd<MonitorMarker>,
    ) -> Self::AddMonitorResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2efbf7d3dc21438e,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<ControllerAddMonitorRequest, ()>(
            (monitor,),
            0x2efbf7d3dc21438e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type FuzzResponseFut = fidl::client::QueryResponseFut<
        ControllerFuzzResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#fuzz(&self) -> Self::FuzzResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#try_one(&self, mut test_input: Input) -> Self::TryOneResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#minimize(&self, mut test_input: Input) -> Self::MinimizeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#cleanse(&self, mut test_input: Input) -> Self::CleanseResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#merge(&self) -> Self::MergeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#get_status(&self) -> Self::GetStatusResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Status, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ControllerGetStatusResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#watch_artifact(&self) -> Self::WatchArtifactResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Artifact, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ControllerWatchArtifactResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

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: <fidl::encoding::DefaultFuchsiaResourceDialect 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 fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl 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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::ProtocolMarker for ControllerProviderMarker {
    type Proxy = ControllerProviderProxy;
    type RequestStream = ControllerProviderRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ControllerProviderSynchronousProxy;

    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: fidl::endpoints::ServerEnd<ControllerMarker>,
    ) -> Self::ConnectResponseFut;
    fn r#stop(&self) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ControllerProviderSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ControllerProviderSynchronousProxy {
    type Proxy = ControllerProviderProxy;
    type Protocol = ControllerProviderMarker;

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

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

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

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

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

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

    /// 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: fidl::endpoints::ServerEnd<ControllerMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self
            .client
            .send_query::<ControllerProviderConnectRequest, fidl::encoding::EmptyPayload>(
                (controller,),
                0xc0325f0732defcb,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    /// Interrupt any current workflow, closes the channel, and exits the
    /// fuzzing engine.
    pub fn r#stop(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x6cd6a98fc38bcbf2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> 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: fidl::endpoints::ServerEnd<ControllerMarker>,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        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<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#connect(
        &self,
        mut controller: fidl::endpoints::ServerEnd<ControllerMarker>,
    ) -> Self::ConnectResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

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: <fidl::encoding::DefaultFuchsiaResourceDialect 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 fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl 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 fidl::endpoints::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 fidl::endpoints::ProtocolMarker for CorpusReaderMarker {
    type Proxy = CorpusReaderProxy;
    type RequestStream = CorpusReaderRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = CorpusReaderSynchronousProxy;

    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)]
#[cfg(target_os = "fuchsia")]
pub struct CorpusReaderSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for CorpusReaderSynchronousProxy {
    type Proxy = CorpusReaderProxy;
    type Protocol = CorpusReaderMarker;

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

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

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

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

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

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

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<i32, fidl::Error> {
        let _response =
            self.client.send_query::<CorpusReaderNextRequest, CorpusReaderNextResponse>(
                (&mut test_input,),
                0x68d19e55ea635356,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.result)
    }
}

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

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

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

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

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

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

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

impl CorpusReaderProxyInterface for CorpusReaderProxy {
    type NextResponseFut =
        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#next(&self, mut test_input: Input) -> Self::NextResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                CorpusReaderNextResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

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: <fidl::encoding::DefaultFuchsiaResourceDialect 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 fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl 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 fidl::endpoints::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 fidl::endpoints::ProtocolMarker for CoverageDataCollectorMarker {
    type Proxy = CoverageDataCollectorProxy;
    type RequestStream = CoverageDataCollectorRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = CoverageDataCollectorSynchronousProxy;

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

pub trait CoverageDataCollectorProxyInterface: Send + Sync {
    type InitializeResponseFut: std::future::Future<Output = Result<Options, fidl::Error>> + Send;
    fn r#initialize(
        &self,
        eventpair: fidl::EventPair,
        process: fidl::Process,
    ) -> Self::InitializeResponseFut;
    type AddInline8bitCountersResponseFut: std::future::Future<Output = Result<(), fidl::Error>>
        + Send;
    fn r#add_inline8bit_counters(
        &self,
        inline_8bit_counters: fidl::Vmo,
    ) -> Self::AddInline8bitCountersResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct CoverageDataCollectorSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for CoverageDataCollectorSynchronousProxy {
    type Proxy = CoverageDataCollectorProxy;
    type Protocol = CoverageDataCollectorMarker;

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

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

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

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

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

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

    /// 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: fidl::EventPair,
        mut process: fidl::Process,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Options, fidl::Error> {
        let _response = self.client.send_query::<
            CoverageDataCollectorInitializeRequest,
            CoverageDataCollectorInitializeResponse,
        >(
            (eventpair, process,),
            0x51d6f91d6f02d9d6,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.options)
    }

    /// 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: fidl::Vmo,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            CoverageDataCollectorAddInline8bitCountersRequest,
            fidl::encoding::EmptyPayload,
        >(
            (inline_8bit_counters,),
            0x75f87cadfc94d1be,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }
}

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

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

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

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

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

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

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> 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: fidl::EventPair,
        mut process: fidl::Process,
    ) -> fidl::client::QueryResponseFut<Options, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        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: fidl::Vmo,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        CoverageDataCollectorProxyInterface::r#add_inline8bit_counters(self, inline_8bit_counters)
    }
}

impl CoverageDataCollectorProxyInterface for CoverageDataCollectorProxy {
    type InitializeResponseFut =
        fidl::client::QueryResponseFut<Options, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#initialize(
        &self,
        mut eventpair: fidl::EventPair,
        mut process: fidl::Process,
    ) -> Self::InitializeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Options, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                CoverageDataCollectorInitializeResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#add_inline8bit_counters(
        &self,
        mut inline_8bit_counters: fidl::Vmo,
    ) -> Self::AddInline8bitCountersResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

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: <fidl::encoding::DefaultFuchsiaResourceDialect 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 fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

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

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                0x51d6f91d6f02d9d6 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(CoverageDataCollectorInitializeRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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 fidl::endpoints::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: fidl::EventPair,
        process: fidl::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: fidl::Vmo,
        responder: CoverageDataCollectorAddInline8bitCountersResponder,
    },
}

impl CoverageDataCollectorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_initialize(
        self,
    ) -> Option<(fidl::EventPair, fidl::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<(fidl::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<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

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

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

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

impl 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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::ProtocolMarker for CoverageDataProviderMarker {
    type Proxy = CoverageDataProviderProxy;
    type RequestStream = CoverageDataProviderRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = CoverageDataProviderSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.fuzzer.CoverageDataProvider";
}
impl fidl::endpoints::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)]
#[cfg(target_os = "fuchsia")]
pub struct CoverageDataProviderSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for CoverageDataProviderSynchronousProxy {
    type Proxy = CoverageDataProviderProxy;
    type Protocol = CoverageDataProviderMarker;

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

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

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

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

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

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

    /// Sets the options to be returned by `fuchsia.fuzzer.CoverageDataCollector/Initialize`.
    pub fn r#set_options(&self, mut options: &Options) -> Result<(), fidl::Error> {
        self.client.send::<CoverageDataProviderSetOptionsRequest>(
            (options,),
            0x4873c4a5c7683384,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Vec<CoverageData>, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            CoverageDataProviderWatchCoverageDataResponse,
        >(
            (),
            0x34a92fc9c73bea5a,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.coverage_data)
    }
}

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

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

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

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

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

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

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> 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>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#watch_coverage_data(&self) -> Self::WatchCoverageDataResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<CoverageData>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                CoverageDataProviderWatchCoverageDataResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

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: <fidl::encoding::DefaultFuchsiaResourceDialect 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 fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

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

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                0x4873c4a5c7683384 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(CoverageDataProviderSetOptionsRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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 fidl::endpoints::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<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

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

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

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

impl 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 fidl::endpoints::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 fidl::endpoints::ProtocolMarker for ManagerMarker {
    type Proxy = ManagerProxy;
    type RequestStream = ManagerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ManagerSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.fuzzer.Manager";
}
impl fidl::endpoints::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: fidl::endpoints::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: fidl::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)]
#[cfg(target_os = "fuchsia")]
pub struct ManagerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ManagerSynchronousProxy {
    type Proxy = ManagerProxy;
    type Protocol = ManagerMarker;

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

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

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

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

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

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

    /// 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: fidl::endpoints::ServerEnd<ControllerMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ManagerConnectResult, fidl::Error> {
        let _response = self.client.send_query::<
            ManagerConnectRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (fuzzer_url, controller,),
            0x1620cd742a89f064,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// 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: fidl::Socket,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ManagerGetOutputResult, fidl::Error> {
        let _response = self.client.send_query::<
            ManagerGetOutputRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (fuzzer_url, output, socket,),
            0x755c28eecf20a88d,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ManagerStopResult, fidl::Error> {
        let _response = self.client.send_query::<
            ManagerStopRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (fuzzer_url,),
            0x27e53d86badd21f3,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

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

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> 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: fidl::endpoints::ServerEnd<ControllerMarker>,
    ) -> fidl::client::QueryResponseFut<
        ManagerConnectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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: fidl::Socket,
    ) -> fidl::client::QueryResponseFut<
        ManagerGetOutputResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ManagerProxyInterface::r#stop(self, fuzzer_url)
    }
}

impl ManagerProxyInterface for ManagerProxy {
    type ConnectResponseFut = fidl::client::QueryResponseFut<
        ManagerConnectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#connect(
        &self,
        mut fuzzer_url: &str,
        mut controller: fidl::endpoints::ServerEnd<ControllerMarker>,
    ) -> Self::ConnectResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_output(
        &self,
        mut fuzzer_url: &str,
        mut output: TestOutput,
        mut socket: fidl::Socket,
    ) -> Self::GetOutputResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#stop(&self, mut fuzzer_url: &str) -> Self::StopResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

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: <fidl::encoding::DefaultFuchsiaResourceDialect 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 fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl 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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::ProtocolMarker for MonitorMarker {
    type Proxy = MonitorProxy;
    type RequestStream = MonitorRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = MonitorSynchronousProxy;

    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)]
#[cfg(target_os = "fuchsia")]
pub struct MonitorSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for MonitorSynchronousProxy {
    type Proxy = MonitorProxy;
    type Protocol = MonitorMarker;

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

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

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

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

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

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

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response =
            self.client.send_query::<MonitorUpdateRequest, fidl::encoding::EmptyPayload>(
                (reason, status),
                0x7c773b93c1e6080f,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }
}

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

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

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

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

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

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

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> 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<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        MonitorProxyInterface::r#update(self, reason, status)
    }
}

impl MonitorProxyInterface for MonitorProxy {
    type UpdateResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#update(&self, mut reason: UpdateReason, mut status: &Status) -> Self::UpdateResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

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: <fidl::encoding::DefaultFuchsiaResourceDialect 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 fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl 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 fidl::endpoints::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 fidl::endpoints::ProtocolMarker for RegistrarMarker {
    type Proxy = RegistrarProxy;
    type RequestStream = RegistrarRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = RegistrarSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.fuzzer.Registrar";
}
impl fidl::endpoints::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: fidl::endpoints::ClientEnd<ControllerProviderMarker>,
    ) -> Self::RegisterResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct RegistrarSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for RegistrarSynchronousProxy {
    type Proxy = RegistrarProxy;
    type Protocol = RegistrarMarker;

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

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

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

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

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

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

    /// 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: fidl::endpoints::ClientEnd<ControllerProviderMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response =
            self.client.send_query::<RegistrarRegisterRequest, fidl::encoding::EmptyPayload>(
                (fuzzer_url, provider),
                0x1716ac38e74b2840,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }
}

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

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

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

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

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

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

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> 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: fidl::endpoints::ClientEnd<ControllerProviderMarker>,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        RegistrarProxyInterface::r#register(self, fuzzer_url, provider)
    }
}

impl RegistrarProxyInterface for RegistrarProxy {
    type RegisterResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#register(
        &self,
        mut fuzzer_url: &str,
        mut provider: fidl::endpoints::ClientEnd<ControllerProviderMarker>,
    ) -> Self::RegisterResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

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: <fidl::encoding::DefaultFuchsiaResourceDialect 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 fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

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

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x1716ac38e74b2840 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RegistrarRegisterRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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 fidl::endpoints::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: fidl::endpoints::ClientEnd<ControllerProviderMarker>,
        responder: RegistrarRegisterResponder,
    },
}

impl RegistrarRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_register(
        self,
    ) -> Option<(
        String,
        fidl::endpoints::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<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

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

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

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

impl 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 fidl::endpoints::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 fidl::endpoints::ProtocolMarker for RegistryMarker {
    type Proxy = RegistryProxy;
    type RequestStream = RegistryRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = RegistrySynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.fuzzer.Registry";
}
impl fidl::endpoints::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: fidl::endpoints::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)]
#[cfg(target_os = "fuchsia")]
pub struct RegistrySynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for RegistrySynchronousProxy {
    type Proxy = RegistryProxy;
    type Protocol = RegistryMarker;

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

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

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

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

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

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

    /// 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: fidl::endpoints::ServerEnd<ControllerMarker>,
        mut timeout: i64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RegistryConnectResult, fidl::Error> {
        let _response = self.client.send_query::<
            RegistryConnectRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (fuzzer_url, controller, timeout,),
            0x5128cb31967a446f,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RegistryDisconnectResult, fidl::Error> {
        let _response = self.client.send_query::<
            RegistryDisconnectRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (fuzzer_url,),
            0x7bb4b7591146d4cb,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

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

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> 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: fidl::endpoints::ServerEnd<ControllerMarker>,
        mut timeout: i64,
    ) -> fidl::client::QueryResponseFut<
        RegistryConnectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RegistryProxyInterface::r#disconnect(self, fuzzer_url)
    }
}

impl RegistryProxyInterface for RegistryProxy {
    type ConnectResponseFut = fidl::client::QueryResponseFut<
        RegistryConnectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#connect(
        &self,
        mut fuzzer_url: &str,
        mut controller: fidl::endpoints::ServerEnd<ControllerMarker>,
        mut timeout: i64,
    ) -> Self::ConnectResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#disconnect(&self, mut fuzzer_url: &str) -> Self::DisconnectResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect 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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

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: <fidl::encoding::DefaultFuchsiaResourceDialect 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 fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl 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 fidl::endpoints::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 fidl::endpoints::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 fidl::endpoints::ProtocolMarker for TargetAdapterMarker {
    type Proxy = TargetAdapterProxy;
    type RequestStream = TargetAdapterRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = TargetAdapterSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.fuzzer.TargetAdapter";
}
impl fidl::endpoints::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: fidl::EventPair,
        test_input: fidl::Vmo,
    ) -> Self::ConnectResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct TargetAdapterSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for TargetAdapterSynchronousProxy {
    type Proxy = TargetAdapterProxy;
    type Protocol = TargetAdapterMarker;

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

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

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

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

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

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

    /// 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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Vec<String>, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, TargetAdapterGetParametersResponse>(
                (),
                0x5c7e40a47f753e3e,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.parameters)
    }

    /// 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: fidl::EventPair,
        mut test_input: fidl::Vmo,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response =
            self.client.send_query::<TargetAdapterConnectRequest, fidl::encoding::EmptyPayload>(
                (eventpair, test_input),
                0x7ea603a119866618,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }
}

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

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

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

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

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

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

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> 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>, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        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: fidl::EventPair,
        mut test_input: fidl::Vmo,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        TargetAdapterProxyInterface::r#connect(self, eventpair, test_input)
    }
}

impl TargetAdapterProxyInterface for TargetAdapterProxy {
    type GetParametersResponseFut =
        fidl::client::QueryResponseFut<Vec<String>, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#get_parameters(&self) -> Self::GetParametersResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<String>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                TargetAdapterGetParametersResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#connect(
        &self,
        mut eventpair: fidl::EventPair,
        mut test_input: fidl::Vmo,
    ) -> Self::ConnectResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                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<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

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: <fidl::encoding::DefaultFuchsiaResourceDialect 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 fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

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

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x5c7e40a47f753e3e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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 fidl::endpoints::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: fidl::EventPair,
        test_input: fidl::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<(fidl::EventPair, fidl::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<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

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

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

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

impl 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 fidl::endpoints::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 fidl::endpoints::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::*;
    unsafe impl fidl::encoding::TypeMarker for OutputFlags {
        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
        }
    }

    impl fidl::encoding::ValueTypeMarker for OutputFlags {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for OutputFlags {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            if self.bits() & Self::all().bits() != self.bits() {
                return Err(fidl::Error::InvalidBitsValue);
            }
            encoder.write_num(self.bits(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OutputFlags {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::empty()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);
            *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for Corpus {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u8>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u8>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            false
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for Corpus {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Corpus {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Corpus {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::unknown()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u8>(offset);

            *self = Self::from_primitive_allow_unknown(prim);
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for Result_ {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u32>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            false
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for Result_ {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Result_ {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Result_ {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::unknown()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);

            *self = Self::from_primitive_allow_unknown(prim);
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for TestOutput {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u32>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            false
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for TestOutput {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for TestOutput {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TestOutput {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::unknown()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);

            *self = Self::from_primitive_allow_unknown(prim);
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for UpdateReason {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u8>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u8>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            false
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for UpdateReason {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for UpdateReason {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UpdateReason {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::unknown()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u8>(offset);

            *self = Self::from_primitive_allow_unknown(prim);
            Ok(())
        }
    }

    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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ControllerAddMonitorRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ControllerAddMonitorRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ControllerAddMonitorRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<MonitorMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.monitor),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<MonitorMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            ControllerAddMonitorRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ControllerAddMonitorRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                monitor: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<MonitorMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<MonitorMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ControllerAddToCorpusRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ControllerAddToCorpusRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                ControllerAddToCorpusRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::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, fidl::encoding::DefaultFuchsiaResourceDialect>,
            T1: fidl::encoding::Encode<Input, fidl::encoding::DefaultFuchsiaResourceDialect>,
        >
        fidl::encoding::Encode<
            ControllerAddToCorpusRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ControllerAddToCorpusRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                corpus: fidl::new_empty!(Corpus, fidl::encoding::DefaultFuchsiaResourceDialect),
                input: fidl::new_empty!(Input, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 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,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.corpus,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                Input,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ControllerCleanseRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ControllerCleanseRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                ControllerCleanseRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<Input as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.test_input,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<T0: fidl::encoding::Encode<Input, fidl::encoding::DefaultFuchsiaResourceDialect>>
        fidl::encoding::Encode<
            ControllerCleanseRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ControllerCleanseRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                test_input: fidl::new_empty!(Input, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

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

    impl fidl::encoding::ValueTypeMarker for ControllerConfigureRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ControllerConfigureRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<ControllerConfigureRequest, D> for &ControllerConfigureRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ControllerConfigureRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ControllerConfigureRequest, D>::encode(
                (<Options as fidl::encoding::ValueTypeMarker>::borrow(&self.options),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Options, D>>
        fidl::encoding::Encode<ControllerConfigureRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ControllerConfigureRequest>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for ControllerConfigureRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { options: fidl::new_empty!(Options, D) }
        }

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

    impl fidl::encoding::ValueTypeMarker for ControllerGetOptionsResponse {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ControllerGetOptionsResponse {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<ControllerGetOptionsResponse, D> for &ControllerGetOptionsResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ControllerGetOptionsResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ControllerGetOptionsResponse, D>::encode(
                (<Options as fidl::encoding::ValueTypeMarker>::borrow(&self.options),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Options, D>>
        fidl::encoding::Encode<ControllerGetOptionsResponse, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ControllerGetOptionsResponse>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for ControllerGetOptionsResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { options: fidl::new_empty!(Options, D) }
        }

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

    impl fidl::encoding::ValueTypeMarker for ControllerGetStatusResponse {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ControllerGetStatusResponse {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<ControllerGetStatusResponse, D> for &ControllerGetStatusResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ControllerGetStatusResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ControllerGetStatusResponse, D>::encode(
                (<Status as fidl::encoding::ValueTypeMarker>::borrow(&self.status),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Status, D>>
        fidl::encoding::Encode<ControllerGetStatusResponse, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ControllerGetStatusResponse>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for ControllerGetStatusResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { status: fidl::new_empty!(Status, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(Status, D, &mut self.status, 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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ControllerMinimizeRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ControllerMinimizeRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                ControllerMinimizeRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<Input as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.test_input,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<T0: fidl::encoding::Encode<Input, fidl::encoding::DefaultFuchsiaResourceDialect>>
        fidl::encoding::Encode<
            ControllerMinimizeRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ControllerMinimizeRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                test_input: fidl::new_empty!(Input, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                Input,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ControllerProviderConnectRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ControllerProviderConnectRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ControllerProviderConnectRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ControllerMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.controller),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ControllerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            ControllerProviderConnectRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ControllerProviderConnectRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                controller: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ControllerMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ControllerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ControllerReadCorpusRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ControllerReadCorpusRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ControllerReadCorpusRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <Corpus as fidl::encoding::ValueTypeMarker>::borrow(&self.corpus),
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<CorpusReaderMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.corpus_reader),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<Corpus, fidl::encoding::DefaultFuchsiaResourceDialect>,
            T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<CorpusReaderMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            ControllerReadCorpusRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ControllerReadCorpusRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                corpus: fidl::new_empty!(Corpus, fidl::encoding::DefaultFuchsiaResourceDialect),
                corpus_reader: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<CorpusReaderMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
            let padval = unsafe { (ptr as *const 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,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.corpus,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<CorpusReaderMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ControllerReadDictionaryResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ControllerReadDictionaryResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                ControllerReadDictionaryResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<Input as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.dictionary,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<T0: fidl::encoding::Encode<Input, fidl::encoding::DefaultFuchsiaResourceDialect>>
        fidl::encoding::Encode<
            ControllerReadDictionaryResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ControllerReadDictionaryResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                dictionary: fidl::new_empty!(Input, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                Input,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ControllerTryOneRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ControllerTryOneRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                ControllerTryOneRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<Input as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.test_input,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<T0: fidl::encoding::Encode<Input, fidl::encoding::DefaultFuchsiaResourceDialect>>
        fidl::encoding::Encode<
            ControllerTryOneRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ControllerTryOneRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                test_input: fidl::new_empty!(Input, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                Input,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ControllerWatchArtifactResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ControllerWatchArtifactResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                ControllerWatchArtifactResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<Artifact as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.artifact,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<T0: fidl::encoding::Encode<Artifact, fidl::encoding::DefaultFuchsiaResourceDialect>>
        fidl::encoding::Encode<
            ControllerWatchArtifactResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ControllerWatchArtifactResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                artifact: fidl::new_empty!(Artifact, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                Artifact,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ControllerWriteDictionaryRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ControllerWriteDictionaryRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                ControllerWriteDictionaryRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<Input as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.dictionary,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<T0: fidl::encoding::Encode<Input, fidl::encoding::DefaultFuchsiaResourceDialect>>
        fidl::encoding::Encode<
            ControllerWriteDictionaryRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ControllerWriteDictionaryRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                dictionary: fidl::new_empty!(Input, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                Input,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut CorpusReaderNextRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CorpusReaderNextRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                CorpusReaderNextRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<Input as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.test_input,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<T0: fidl::encoding::Encode<Input, fidl::encoding::DefaultFuchsiaResourceDialect>>
        fidl::encoding::Encode<
            CorpusReaderNextRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for CorpusReaderNextRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                test_input: fidl::new_empty!(Input, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

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

    impl fidl::encoding::ValueTypeMarker for CorpusReaderNextResponse {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for CorpusReaderNextResponse {
        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
        }
        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            true
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<CorpusReaderNextResponse, D> for &CorpusReaderNextResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CorpusReaderNextResponse>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut CorpusReaderNextResponse)
                    .write_unaligned((self as *const CorpusReaderNextResponse).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
            }
            Ok(())
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i32, D>>
        fidl::encoding::Encode<CorpusReaderNextResponse, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CorpusReaderNextResponse>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for CorpusReaderNextResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { result: fidl::new_empty!(i32, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
            }
            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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut CoverageData
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CoverageData>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<CoverageData, fidl::encoding::DefaultFuchsiaResourceDialect>::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, fidl::encoding::DefaultFuchsiaResourceDialect>,
            T1: fidl::encoding::Encode<Data, fidl::encoding::DefaultFuchsiaResourceDialect>,
        > fidl::encoding::Encode<CoverageData, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect> for CoverageData {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                target_id: fidl::new_empty!(u64, fidl::encoding::DefaultFuchsiaResourceDialect),
                data: fidl::new_empty!(Data, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                u64,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.target_id,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                Data,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut CoverageDataCollectorAddInline8bitCountersRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CoverageDataCollectorAddInline8bitCountersRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                CoverageDataCollectorAddInline8bitCountersRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<fidl::encoding::HandleType<
                    fidl::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<
                    fidl::Vmo,
                    { fidl::ObjectType::VMO.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            CoverageDataCollectorAddInline8bitCountersRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for CoverageDataCollectorAddInline8bitCountersRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                inline_8bit_counters: fidl::new_empty!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

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

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

    impl fidl::encoding::ValueTypeMarker for CoverageDataCollectorInitializeResponse {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for CoverageDataCollectorInitializeResponse {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<CoverageDataCollectorInitializeResponse, D>
        for &CoverageDataCollectorInitializeResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CoverageDataCollectorInitializeResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<CoverageDataCollectorInitializeResponse, D>::encode(
                (<Options as fidl::encoding::ValueTypeMarker>::borrow(&self.options),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Options, D>>
        fidl::encoding::Encode<CoverageDataCollectorInitializeResponse, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CoverageDataCollectorInitializeResponse>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for CoverageDataCollectorInitializeResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { options: fidl::new_empty!(Options, D) }
        }

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

    impl fidl::encoding::ValueTypeMarker for CoverageDataProviderSetOptionsRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for CoverageDataProviderSetOptionsRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<CoverageDataProviderSetOptionsRequest, D>
        for &CoverageDataProviderSetOptionsRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CoverageDataProviderSetOptionsRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<CoverageDataProviderSetOptionsRequest, D>::encode(
                (<Options as fidl::encoding::ValueTypeMarker>::borrow(&self.options),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Options, D>>
        fidl::encoding::Encode<CoverageDataProviderSetOptionsRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CoverageDataProviderSetOptionsRequest>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for CoverageDataProviderSetOptionsRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { options: fidl::new_empty!(Options, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(Options, D, &mut self.options, decoder, offset + 0, _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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut CoverageDataProviderWatchCoverageDataResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CoverageDataProviderWatchCoverageDataResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<CoverageDataProviderWatchCoverageDataResponse, fidl::encoding::DefaultFuchsiaResourceDialect>::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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            CoverageDataProviderWatchCoverageDataResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for CoverageDataProviderWatchCoverageDataResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                coverage_data: fidl::new_empty!(fidl::encoding::Vector<CoverageData, 4096>, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(fidl::encoding::Vector<CoverageData, 4096>, fidl::encoding::DefaultFuchsiaResourceDialect, &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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut Input
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Input>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<Input, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::HandleType<
                        fidl::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<
                    fidl::Socket,
                    { fidl::ObjectType::SOCKET.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<u64, fidl::encoding::DefaultFuchsiaResourceDialect>,
        > fidl::encoding::Encode<Input, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect> for Input {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                socket: fidl::new_empty!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
                size: fidl::new_empty!(u64, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.socket, decoder, offset + 0, _depth)?;
            fidl::decode!(
                u64,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut InstrumentedProcess
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<InstrumentedProcess>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                InstrumentedProcess,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <fidl::encoding::HandleType<
                        fidl::EventPair,
                        { fidl::ObjectType::EVENTPAIR.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.eventpair
                    ),
                    <fidl::encoding::HandleType<
                        fidl::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<
                    fidl::EventPair,
                    { fidl::ObjectType::EVENTPAIR.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::Process,
                    { fidl::ObjectType::PROCESS.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<InstrumentedProcess, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for InstrumentedProcess
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                eventpair: fidl::new_empty!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
                process: fidl::new_empty!(fidl::encoding::HandleType<fidl::Process, { fidl::ObjectType::PROCESS.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.eventpair, decoder, offset + 0, _depth)?;
            fidl::decode!(fidl::encoding::HandleType<fidl::Process, { fidl::ObjectType::PROCESS.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut ManagerConnectRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ManagerConnectRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ManagerConnectRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(&self.fuzzer_url),
                    <fidl::encoding::Endpoint<fidl::endpoints::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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ControllerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<ManagerConnectRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ManagerConnectRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                fuzzer_url: fidl::new_empty!(
                    fidl::encoding::BoundedString<4096>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                controller: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ControllerMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl::encoding::BoundedString<4096>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.fuzzer_url,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ControllerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ManagerGetOutputRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ManagerGetOutputRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ManagerGetOutputRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(&self.fuzzer_url),
                    <TestOutput as fidl::encoding::ValueTypeMarker>::borrow(&self.output),
                    <fidl::encoding::HandleType<fidl::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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<TestOutput, fidl::encoding::DefaultFuchsiaResourceDialect>,
            T2: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::Socket,
                    { fidl::ObjectType::SOCKET.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            ManagerGetOutputRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ManagerGetOutputRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                fuzzer_url: fidl::new_empty!(
                    fidl::encoding::BoundedString<4096>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                output: fidl::new_empty!(TestOutput, fidl::encoding::DefaultFuchsiaResourceDialect),
                socket: fidl::new_empty!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

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

    impl fidl::encoding::ValueTypeMarker for ManagerStopRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ManagerStopRequest {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ManagerStopRequest, D>
        for &ManagerStopRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ManagerStopRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ManagerStopRequest, D>::encode(
                (<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(
                    &self.fuzzer_url,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
        > fidl::encoding::Encode<ManagerStopRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ManagerStopRequest>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ManagerStopRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { fuzzer_url: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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>,
                D,
                &mut self.fuzzer_url,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for MonitorUpdateRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for MonitorUpdateRequest {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MonitorUpdateRequest, D>
        for &MonitorUpdateRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MonitorUpdateRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MonitorUpdateRequest, D>::encode(
                (
                    <UpdateReason as fidl::encoding::ValueTypeMarker>::borrow(&self.reason),
                    <Status as fidl::encoding::ValueTypeMarker>::borrow(&self.status),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<UpdateReason, D>,
            T1: fidl::encoding::Encode<Status, D>,
        > fidl::encoding::Encode<MonitorUpdateRequest, D> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MonitorUpdateRequest>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MonitorUpdateRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { reason: fidl::new_empty!(UpdateReason, D), status: fidl::new_empty!(Status, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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!(UpdateReason, D, &mut self.reason, decoder, offset + 0, _depth)?;
            fidl::decode!(Status, D, &mut self.status, decoder, offset + 8, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for ProcessStats {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ProcessStats {
        type Owned = Self;

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            72
        }
        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            true
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ProcessStats, D>
        for &ProcessStats
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ProcessStats>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut ProcessStats)
                    .write_unaligned((self as *const ProcessStats).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
            }
            Ok(())
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<u64, D>,
            T1: fidl::encoding::Encode<u64, D>,
            T2: fidl::encoding::Encode<u64, D>,
            T3: fidl::encoding::Encode<u64, D>,
            T4: fidl::encoding::Encode<u64, D>,
            T5: fidl::encoding::Encode<i64, D>,
            T6: fidl::encoding::Encode<i64, D>,
            T7: fidl::encoding::Encode<i64, D>,
            T8: fidl::encoding::Encode<i64, D>,
        > fidl::encoding::Encode<ProcessStats, D> for (T0, T1, T2, T3, T4, T5, T6, T7, T8)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ProcessStats>(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)?;
            self.2.encode(encoder, offset + 16, depth)?;
            self.3.encode(encoder, offset + 24, depth)?;
            self.4.encode(encoder, offset + 32, depth)?;
            self.5.encode(encoder, offset + 40, depth)?;
            self.6.encode(encoder, offset + 48, depth)?;
            self.7.encode(encoder, offset + 56, depth)?;
            self.8.encode(encoder, offset + 64, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ProcessStats {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                koid: fidl::new_empty!(u64, D),
                mem_mapped_bytes: fidl::new_empty!(u64, D),
                mem_private_bytes: fidl::new_empty!(u64, D),
                mem_shared_bytes: fidl::new_empty!(u64, D),
                mem_scaled_shared_bytes: fidl::new_empty!(u64, D),
                cpu_time: fidl::new_empty!(i64, D),
                queue_time: fidl::new_empty!(i64, D),
                page_fault_time: fidl::new_empty!(i64, D),
                lock_contention_time: fidl::new_empty!(i64, D),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 72);
            }
            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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut RegistrarRegisterRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RegistrarRegisterRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RegistrarRegisterRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(&self.fuzzer_url),
                    <fidl::encoding::Endpoint<fidl::endpoints::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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ControllerProviderMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            RegistrarRegisterRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for RegistrarRegisterRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                fuzzer_url: fidl::new_empty!(
                    fidl::encoding::BoundedString<4096>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                provider: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ControllerProviderMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl::encoding::BoundedString<4096>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.fuzzer_url,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ControllerProviderMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut RegistryConnectRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RegistryConnectRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RegistryConnectRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(&self.fuzzer_url),
                    <fidl::encoding::Endpoint<fidl::endpoints::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>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ControllerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T2: fidl::encoding::Encode<i64, fidl::encoding::DefaultFuchsiaResourceDialect>,
        >
        fidl::encoding::Encode<
            RegistryConnectRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for RegistryConnectRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                fuzzer_url: fidl::new_empty!(
                    fidl::encoding::BoundedString<4096>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                controller: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ControllerMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                timeout: fidl::new_empty!(i64, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

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

    impl fidl::encoding::ValueTypeMarker for RegistryDisconnectRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for RegistryDisconnectRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<RegistryDisconnectRequest, D> for &RegistryDisconnectRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RegistryDisconnectRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RegistryDisconnectRequest, D>::encode(
                (<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(
                    &self.fuzzer_url,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
        > fidl::encoding::Encode<RegistryDisconnectRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RegistryDisconnectRequest>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for RegistryDisconnectRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { fuzzer_url: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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>,
                D,
                &mut self.fuzzer_url,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for SanitizerOptions {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for SanitizerOptions {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SanitizerOptions, D>
        for &SanitizerOptions
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SanitizerOptions>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<SanitizerOptions, D>::encode(
                (
                    <fidl::encoding::BoundedString<32> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
                    <fidl::encoding::BoundedString<8192> as fidl::encoding::ValueTypeMarker>::borrow(&self.value),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<32>, D>,
            T1: fidl::encoding::Encode<fidl::encoding::BoundedString<8192>, D>,
        > fidl::encoding::Encode<SanitizerOptions, D> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SanitizerOptions>(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)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SanitizerOptions {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                name: fidl::new_empty!(fidl::encoding::BoundedString<32>, D),
                value: fidl::new_empty!(fidl::encoding::BoundedString<8192>, D),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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<32>,
                D,
                &mut self.name,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::BoundedString<8192>,
                D,
                &mut self.value,
                decoder,
                offset + 16,
                _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,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut TargetAdapterConnectRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TargetAdapterConnectRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                TargetAdapterConnectRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <fidl::encoding::HandleType<
                        fidl::EventPair,
                        { fidl::ObjectType::EVENTPAIR.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.eventpair
                    ),
                    <fidl::encoding::HandleType<
                        fidl::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<
                    fidl::EventPair,
                    { fidl::ObjectType::EVENTPAIR.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::Vmo,
                    { fidl::ObjectType::VMO.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            TargetAdapterConnectRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for TargetAdapterConnectRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                eventpair: fidl::new_empty!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
                test_input: fidl::new_empty!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

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

    impl fidl::encoding::ValueTypeMarker for TargetAdapterGetParametersResponse {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for TargetAdapterGetParametersResponse {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<TargetAdapterGetParametersResponse, D>
        for &TargetAdapterGetParametersResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TargetAdapterGetParametersResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<TargetAdapterGetParametersResponse, D>::encode(
                (
                    <fidl::encoding::Vector<fidl::encoding::BoundedString<256>, 128> as fidl::encoding::ValueTypeMarker>::borrow(&self.parameters),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<
                fidl::encoding::Vector<fidl::encoding::BoundedString<256>, 128>,
                D,
            >,
        > fidl::encoding::Encode<TargetAdapterGetParametersResponse, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TargetAdapterGetParametersResponse>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for TargetAdapterGetParametersResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                parameters: fidl::new_empty!(
                    fidl::encoding::Vector<fidl::encoding::BoundedString<256>, 128>,
                    D
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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<fidl::encoding::BoundedString<256>, 128>,
                D,
                &mut self.parameters,
                decoder,
                offset + 0,
                _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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut Artifact
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            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_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                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,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                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,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                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, fidl::encoding::DefaultFuchsiaResourceDialect> for Artifact {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            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_, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    Result_,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    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, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    Input,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    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, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    i32,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    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 Options {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.output_flags {
                return 22;
            }
            if let Some(_) = self.sanitizer_options {
                return 21;
            }
            if let Some(_) = self.use_value_profile {
                return 20;
            }
            if let Some(_) = self.print_final_stats {
                return 19;
            }
            if let Some(_) = self.debug {
                return 18;
            }
            if let Some(_) = self.pulse_interval {
                return 17;
            }
            if let Some(_) = self.oom_exitcode {
                return 16;
            }
            if let Some(_) = self.leak_exitcode {
                return 15;
            }
            if let Some(_) = self.death_exitcode {
                return 14;
            }
            if let Some(_) = self.malloc_exitcode {
                return 13;
            }
            if let Some(_) = self.purge_interval {
                return 12;
            }
            if let Some(_) = self.oom_limit {
                return 11;
            }
            if let Some(_) = self.malloc_limit {
                return 10;
            }
            if let Some(_) = self.run_limit {
                return 9;
            }
            if let Some(_) = self.detect_leaks {
                return 8;
            }
            if let Some(_) = self.detect_exits {
                return 7;
            }
            if let Some(_) = self.dictionary_level {
                return 6;
            }
            if let Some(_) = self.mutation_depth {
                return 5;
            }
            if let Some(_) = self.max_input_size {
                return 4;
            }
            if let Some(_) = self.seed {
                return 3;
            }
            if let Some(_) = self.max_total_time {
                return 2;
            }
            if let Some(_) = self.runs {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for Options {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for Options {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Options, D> for &Options {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Options>(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::<u32, D>(
                self.runs.as_ref().map(<u32 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::<i64, D>(
                self.max_total_time.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::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::<u32, D>(
                self.seed.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 4 > 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 = (4 - 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::<u64, D>(
                self.max_input_size.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 5 > 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 = (5 - 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::<u16, D>(
                self.mutation_depth.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 6 > 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 = (6 - 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::<u16, D>(
                self.dictionary_level
                    .as_ref()
                    .map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 7 > 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 = (7 - 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::<bool, D>(
                self.detect_exits.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 8 > 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 = (8 - 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::<bool, D>(
                self.detect_leaks.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 9 > 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 = (9 - 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::<i64, D>(
                self.run_limit.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 10 > 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 = (10 - 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::<u64, D>(
                self.malloc_limit.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 11 > 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 = (11 - 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::<u64, D>(
                self.oom_limit.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 12 > 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 = (12 - 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::<i64, D>(
                self.purge_interval.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 13 > 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 = (13 - 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, D>(
                self.malloc_exitcode.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 14 > 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 = (14 - 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, D>(
                self.death_exitcode.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 15 > 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 = (15 - 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, D>(
                self.leak_exitcode.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 16 > 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 = (16 - 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, D>(
                self.oom_exitcode.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 17 > 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 = (17 - 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::<i64, D>(
                self.pulse_interval.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 18 > 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 = (18 - 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::<bool, D>(
                self.debug.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 19 > 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 = (19 - 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::<bool, D>(
                self.print_final_stats
                    .as_ref()
                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 20 > 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 = (20 - 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::<bool, D>(
                self.use_value_profile
                    .as_ref()
                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 21 > 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 = (21 - 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::<SanitizerOptions, D>(
                self.sanitizer_options
                    .as_ref()
                    .map(<SanitizerOptions as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 22 > 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 = (22 - 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::<OutputFlags, D>(
                self.output_flags
                    .as_ref()
                    .map(<OutputFlags as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Options {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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 =
                    <u32 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.runs.get_or_insert_with(|| fidl::new_empty!(u32, D));
                fidl::decode!(u32, D, 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 =
                    <i64 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.max_total_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
                fidl::decode!(i64, D, 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 =
                    <u32 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.seed.get_or_insert_with(|| fidl::new_empty!(u32, D));
                fidl::decode!(u32, D, 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 < 4 {
                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 =
                    <u64 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.max_input_size.get_or_insert_with(|| fidl::new_empty!(u64, D));
                fidl::decode!(u64, D, 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 < 5 {
                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 =
                    <u16 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.mutation_depth.get_or_insert_with(|| fidl::new_empty!(u16, D));
                fidl::decode!(u16, D, 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 < 6 {
                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 =
                    <u16 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.dictionary_level.get_or_insert_with(|| fidl::new_empty!(u16, D));
                fidl::decode!(u16, D, 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 < 7 {
                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 =
                    <bool 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.detect_exits.get_or_insert_with(|| fidl::new_empty!(bool, D));
                fidl::decode!(bool, D, 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 < 8 {
                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 =
                    <bool 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.detect_leaks.get_or_insert_with(|| fidl::new_empty!(bool, D));
                fidl::decode!(bool, D, 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 < 9 {
                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 =
                    <i64 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.run_limit.get_or_insert_with(|| fidl::new_empty!(i64, D));
                fidl::decode!(i64, D, 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 < 10 {
                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 =
                    <u64 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.malloc_limit.get_or_insert_with(|| fidl::new_empty!(u64, D));
                fidl::decode!(u64, D, 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 < 11 {
                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 =
                    <u64 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.oom_limit.get_or_insert_with(|| fidl::new_empty!(u64, D));
                fidl::decode!(u64, D, 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 < 12 {
                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 =
                    <i64 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.purge_interval.get_or_insert_with(|| fidl::new_empty!(i64, D));
                fidl::decode!(i64, D, 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 < 13 {
                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.malloc_exitcode.get_or_insert_with(|| fidl::new_empty!(i32, D));
                fidl::decode!(i32, D, 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 < 14 {
                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.death_exitcode.get_or_insert_with(|| fidl::new_empty!(i32, D));
                fidl::decode!(i32, D, 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 < 15 {
                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.leak_exitcode.get_or_insert_with(|| fidl::new_empty!(i32, D));
                fidl::decode!(i32, D, 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 < 16 {
                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.oom_exitcode.get_or_insert_with(|| fidl::new_empty!(i32, D));
                fidl::decode!(i32, D, 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 < 17 {
                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 =
                    <i64 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.pulse_interval.get_or_insert_with(|| fidl::new_empty!(i64, D));
                fidl::decode!(i64, D, 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 < 18 {
                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 =
                    <bool 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.debug.get_or_insert_with(|| fidl::new_empty!(bool, D));
                fidl::decode!(bool, D, 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 < 19 {
                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 =
                    <bool 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.print_final_stats.get_or_insert_with(|| fidl::new_empty!(bool, D));
                fidl::decode!(bool, D, 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 < 20 {
                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 =
                    <bool 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.use_value_profile.get_or_insert_with(|| fidl::new_empty!(bool, D));
                fidl::decode!(bool, D, 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 < 21 {
                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 =
                    <SanitizerOptions 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
                    .sanitizer_options
                    .get_or_insert_with(|| fidl::new_empty!(SanitizerOptions, D));
                fidl::decode!(SanitizerOptions, D, 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 < 22 {
                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 =
                    <OutputFlags 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.output_flags.get_or_insert_with(|| fidl::new_empty!(OutputFlags, D));
                fidl::decode!(OutputFlags, D, 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 Status {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.process_stats {
                return 8;
            }
            if let Some(_) = self.corpus_total_size {
                return 7;
            }
            if let Some(_) = self.corpus_num_inputs {
                return 6;
            }
            if let Some(_) = self.covered_features {
                return 5;
            }
            if let Some(_) = self.covered_pcs {
                return 4;
            }
            if let Some(_) = self.elapsed {
                return 3;
            }
            if let Some(_) = self.runs {
                return 2;
            }
            if let Some(_) = self.running {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for Status {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for Status {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Status, D> for &Status {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Status>(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::<bool, D>(
                self.running.as_ref().map(<bool 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::<u32, D>(
                self.runs.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::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::<i64, D>(
                self.elapsed.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 4 > 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 = (4 - 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::<u64, D>(
                self.covered_pcs.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 5 > 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 = (5 - 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::<u64, D>(
                self.covered_features
                    .as_ref()
                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 6 > 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 = (6 - 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::<u64, D>(
                self.corpus_num_inputs
                    .as_ref()
                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 7 > 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 = (7 - 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::<u64, D>(
                self.corpus_total_size
                    .as_ref()
                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 8 > 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 = (8 - 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::<fidl::encoding::Vector<ProcessStats, 256>, D>(
            self.process_stats.as_ref().map(<fidl::encoding::Vector<ProcessStats, 256> as fidl::encoding::ValueTypeMarker>::borrow),
            encoder, offset + cur_offset, depth
        )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Status {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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 =
                    <bool 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.running.get_or_insert_with(|| fidl::new_empty!(bool, D));
                fidl::decode!(bool, D, 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 =
                    <u32 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.runs.get_or_insert_with(|| fidl::new_empty!(u32, D));
                fidl::decode!(u32, D, 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 =
                    <i64 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.elapsed.get_or_insert_with(|| fidl::new_empty!(i64, D));
                fidl::decode!(i64, D, 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 < 4 {
                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 =
                    <u64 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.covered_pcs.get_or_insert_with(|| fidl::new_empty!(u64, D));
                fidl::decode!(u64, D, 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 < 5 {
                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 =
                    <u64 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.covered_features.get_or_insert_with(|| fidl::new_empty!(u64, D));
                fidl::decode!(u64, D, 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 < 6 {
                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 =
                    <u64 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.corpus_num_inputs.get_or_insert_with(|| fidl::new_empty!(u64, D));
                fidl::decode!(u64, D, 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 < 7 {
                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 =
                    <u64 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.corpus_total_size.get_or_insert_with(|| fidl::new_empty!(u64, D));
                fidl::decode!(u64, D, 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 < 8 {
                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 = <fidl::encoding::Vector<ProcessStats, 256> 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.process_stats.get_or_insert_with(
                    || fidl::new_empty!(fidl::encoding::Vector<ProcessStats, 256>, D),
                );
                fidl::decode!(fidl::encoding::Vector<ProcessStats, 256>, D, 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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut Data
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Data>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
                Data::Instrumented(ref mut val) => fidl::encoding::encode_in_envelope::<
                    InstrumentedProcess,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <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<
                        fidl::Vmo,
                        { fidl::ObjectType::VMO.into_raw() },
                        2147483648,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <fidl::encoding::HandleType<
                        fidl::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, fidl::encoding::DefaultFuchsiaResourceDialect> for Data {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::__SourceBreaking { unknown_ordinal: 0 }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            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<
                    fidl::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,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Data::Instrumented(ref mut val) = self {
                        fidl::decode!(
                            InstrumentedProcess,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            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<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Data::Inline8bitCounters(ref mut val) = self {
                        fidl::decode!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, 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(())
        }
    }
}