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

// fidl_experiment = no_optional_structs
// fidl_experiment = simple_empty_response_syntax
// fidl_experiment = unknown_interactions

#![allow(
    unused_parens, // one-element-tuple-case is not a tuple
    unused_mut, // not all args require mutation, but many do
    nonstandard_style, // auto-caps does its best, but is not always successful
)]
#![recursion_limit = "512"]

#[cfg(target_os = "fuchsia")]
#[allow(unused_imports)]
use fuchsia_zircon as zx;

#[allow(unused_imports)]
use {
    bitflags::bitflags,
    fidl::{
        client::{decode_transaction_body_fut, QueryResponseFut},
        encoding::{zerocopy, Decodable as _, Encodable as _},
        endpoints::{ControlHandle as _, Responder as _},
        fidl_bits, fidl_empty_struct, fidl_enum, fidl_struct, fidl_struct_copy, fidl_table,
        fidl_union, wrap_handle_metadata,
    },
    fuchsia_zircon_status as zx_status,
    futures::future::{self, MaybeDone, TryFutureExt},
};

const _FIDL_TRACE_BINDINGS_RUST: u32 = 6;
bitflags! {
    pub struct CommandBufferFlags: u64 {
        /// Vendor specific definitions start here
        const VENDOR_FLAG_0 = 65536;
    }
}

impl CommandBufferFlags {
    #[inline(always)]
    pub fn from_bits_allow_unknown(bits: u64) -> Self {
        unsafe { Self::from_bits_unchecked(bits) }
    }

    #[inline(always)]
    pub fn has_unknown_bits(&self) -> bool {
        self.get_unknown_bits() != 0
    }

    #[inline(always)]
    pub fn get_unknown_bits(&self) -> u64 {
        self.bits & !Self::all().bits
    }
}

fidl_bits! {
    name: CommandBufferFlags,
    prim_ty: u64,
    flexible: true,
}

bitflags! {
    pub struct IcdFlags: u32 {
        const SUPPORTS_VULKAN = 1;
        const SUPPORTS_OPENCL = 2;
        const SUPPORTS_MEDIA_CODEC_FACTORY = 4;
    }
}

impl IcdFlags {
    #[inline(always)]
    pub fn from_bits_allow_unknown(bits: u32) -> Self {
        unsafe { Self::from_bits_unchecked(bits) }
    }

    #[inline(always)]
    pub fn has_unknown_bits(&self) -> bool {
        self.get_unknown_bits() != 0
    }

    #[inline(always)]
    pub fn get_unknown_bits(&self) -> u32 {
        self.bits & !Self::all().bits
    }
}

fidl_bits! {
    name: IcdFlags,
    prim_ty: u32,
    flexible: true,
}

bitflags! {
    pub struct MapFlags: u64 {
        const READ = 1;
        const WRITE = 2;
        const EXECUTE = 4;
        /// Uncommitted pages may be comitted on a hardware fault. If this flag is not set, access
        /// faults should cause an error.
        const GROWABLE = 8;
        /// Vendor specific definitions start here
        const VENDOR_FLAG_0 = 65536;
    }
}

impl MapFlags {
    #[inline(always)]
    pub fn from_bits_allow_unknown(bits: u64) -> Self {
        unsafe { Self::from_bits_unchecked(bits) }
    }

    #[inline(always)]
    pub fn has_unknown_bits(&self) -> bool {
        self.get_unknown_bits() != 0
    }

    #[inline(always)]
    pub fn get_unknown_bits(&self) -> u64 {
        self.bits & !Self::all().bits
    }
}

fidl_bits! {
    name: MapFlags,
    prim_ty: u64,
    flexible: true,
}

bitflags! {
    pub struct ResultFlags: u32 {
        /// This bit is set in result_flags if the performance counters missed some samples, e.g. due to
        /// the hardware being in protected mode for part of the time.
        const DISCONTINUITY = 1;
    }
}

impl ResultFlags {
    #[inline(always)]
    pub fn from_bits_allow_unknown(bits: u32) -> Self {
        unsafe { Self::from_bits_unchecked(bits) }
    }

    #[inline(always)]
    pub fn has_unknown_bits(&self) -> bool {
        self.get_unknown_bits() != 0
    }

    #[inline(always)]
    pub fn get_unknown_bits(&self) -> u32 {
        self.bits & !Self::all().bits
    }
}

fidl_bits! {
    name: ResultFlags,
    prim_ty: u32,
    flexible: true,
}

/// The maximum number of ICDs supported by a Magma system driver.
pub const MAX_ICD_COUNT: u64 = 8;

/// The batch size used to send multiple immediate commands in a single message.
pub const MAX_IMMEDIATE_COMMANDS_DATA_SIZE: u32 = 2048;

#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[non_exhaustive]
pub enum BufferOp {
    /// Populate the hardware page tables with the pages mapped in this range, committing pages
    /// as needed. This is not needed for allocations mapped GROWABLE, since the page tables will
    /// be populated on demand.
    PopulateTables,
    /// Depopulate page table mappings for this range. This prevents the hardware from accessing
    /// pages in that range, but the pages retain their contents.
    DepopulateTables,
    #[deprecated = "Use `BufferOp::unknown()` to construct and `BufferOpUnknown!()` to exhaustively match."]
    #[doc(hidden)]
    __Unknown(u32),
}
/// Pattern that matches an unknown `BufferOp` member.
#[macro_export]
macro_rules! BufferOpUnknown {
    () => {
        _
    };
}

impl BufferOp {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            1 => Some(Self::PopulateTables),
            2 => Some(Self::DepopulateTables),
            _ => None,
        }
    }

    #[inline]
    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
        match prim {
            1 => Self::PopulateTables,
            2 => Self::DepopulateTables,
            #[allow(deprecated)]
            x => Self::__Unknown(x),
        }
    }

    #[inline]
    pub fn unknown() -> Self {
        #[allow(deprecated)]
        Self::__Unknown(0xffffffff)
    }

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        match self {
            Self::PopulateTables => 1,
            Self::DepopulateTables => 2,
            #[allow(deprecated)]
            Self::__Unknown(x) => x,
        }
    }

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

fidl_enum! {
    name: BufferOp,
    prim_ty: u32,
    flexible: true,
}

#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[non_exhaustive]
pub enum ObjectType {
    /// A sync object backed by a Zircon event.
    Event,
    /// A memory object backeed by a Zircon VMO.
    Buffer,
    #[deprecated = "Use `ObjectType::unknown()` to construct and `ObjectTypeUnknown!()` to exhaustively match."]
    #[doc(hidden)]
    __Unknown(u32),
}
/// Pattern that matches an unknown `ObjectType` member.
#[macro_export]
macro_rules! ObjectTypeUnknown {
    () => {
        _
    };
}

impl ObjectType {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            10 => Some(Self::Event),
            11 => Some(Self::Buffer),
            _ => None,
        }
    }

    #[inline]
    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
        match prim {
            10 => Self::Event,
            11 => Self::Buffer,
            #[allow(deprecated)]
            x => Self::__Unknown(x),
        }
    }

    #[inline]
    pub fn unknown() -> Self {
        #[allow(deprecated)]
        Self::__Unknown(0xffffffff)
    }

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        match self {
            Self::Event => 10,
            Self::Buffer => 11,
            #[allow(deprecated)]
            Self::__Unknown(x) => x,
        }
    }

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

fidl_enum! {
    name: ObjectType,
    prim_ty: u32,
    flexible: true,
}

/// Types of information about the hardware and driver that can be queried from the Magma system
/// driver. Vendor-specific ID numbers may be used, but those IDs will be listed elsewhere.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[non_exhaustive]
pub enum QueryId {
    /// Returns the hardware vendor ID (simple result) - should be the PCI ID of the hardware
    /// vendor if possible, or the Khronos vendor ID otherwise.
    VendorId,
    /// Returns the hardware device ID (simple result)
    DeviceId,
    /// Returns the version of the vendor interfaces supported by the system driver.
    VendorVersion,
    /// Returns true if MAGMA_QUERY_TOTAL_TIME is supported (simple result)
    IsTotalTimeSupported,
    /// Upper 32bits: max inflight messages, lower 32bits: max inflight memory (MB) (simple result)
    MaximumInflightParams,
    /// Returns a struct magma_total_time_query_result (buffer result); see:
    /// src/graphics/lib/magma/include/magma/magma_common_defs.h
    MagmaQueryTotalTime,
    /// Vendor specific query IDs start here
    VendorQuery0,
    #[deprecated = "Use `QueryId::unknown()` to construct and `QueryIdUnknown!()` to exhaustively match."]
    #[doc(hidden)]
    __Unknown(u64),
}
/// Pattern that matches an unknown `QueryId` member.
#[macro_export]
macro_rules! QueryIdUnknown {
    () => {
        _
    };
}

impl QueryId {
    #[inline]
    pub fn from_primitive(prim: u64) -> Option<Self> {
        match prim {
            0 => Some(Self::VendorId),
            1 => Some(Self::DeviceId),
            2 => Some(Self::VendorVersion),
            3 => Some(Self::IsTotalTimeSupported),
            5 => Some(Self::MaximumInflightParams),
            500 => Some(Self::MagmaQueryTotalTime),
            10000 => Some(Self::VendorQuery0),
            _ => None,
        }
    }

    #[inline]
    pub fn from_primitive_allow_unknown(prim: u64) -> Self {
        match prim {
            0 => Self::VendorId,
            1 => Self::DeviceId,
            2 => Self::VendorVersion,
            3 => Self::IsTotalTimeSupported,
            5 => Self::MaximumInflightParams,
            500 => Self::MagmaQueryTotalTime,
            10000 => Self::VendorQuery0,
            #[allow(deprecated)]
            x => Self::__Unknown(x),
        }
    }

    #[inline]
    pub fn unknown() -> Self {
        #[allow(deprecated)]
        Self::__Unknown(0xffffffffffffffff)
    }

    #[inline]
    pub const fn into_primitive(self) -> u64 {
        match self {
            Self::VendorId => 0,
            Self::DeviceId => 1,
            Self::VendorVersion => 2,
            Self::IsTotalTimeSupported => 3,
            Self::MaximumInflightParams => 5,
            Self::MagmaQueryTotalTime => 500,
            Self::VendorQuery0 => 10000,
            #[allow(deprecated)]
            Self::__Unknown(x) => x,
        }
    }

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

fidl_enum! {
    name: QueryId,
    prim_ty: u64,
    flexible: true,
}

pub type DeviceQueryResult = Result<(DeviceQueryResponse), i32>;

/// Handle-type validating wrapper for DeviceQueryResult responses, used internally by
/// FIDL bindings to decode method results. This should only be used by
/// generated APIs, API users should never need to use this type. It is public
/// because it is shared with composed protocols.
#[doc(hidden)]
pub type DeviceQueryResultHandleWrapper = Result<(DeviceQueryResponse,), i32>;

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum DeviceQueryResponse {
    SimpleResult(u64),
    BufferResult(fidl::Vmo),
}

impl DeviceQueryResponse {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::SimpleResult(_) => 1,
            Self::BufferResult(_) => 2,
        }
    }
    #[deprecated = "Strict unions should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

impl fidl::encoding::TopLevel for DeviceQueryResponse {}

fidl_union! {
    name: DeviceQueryResponse,
    members: [
        SimpleResult {
            ty: u64,
            ordinal: 1,
        },
        BufferResult {
            ty: fidl::Vmo,
            ordinal: 2,
            handle_metadata: {
                handle_subtype: fidl::ObjectType::VMO,
                handle_rights: fidl::Rights::from_bits_const(2147483648).unwrap(),
            },
        },
    ],
}

#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[repr(C)]
pub struct BufferRange {
    pub buffer_id: u64,
    pub offset: u64,
    pub size: u64,
}

impl fidl::encoding::TopLevel for BufferRange {}

impl fidl::encoding::Persistable for BufferRange {}

fidl_struct_copy! {
    name: BufferRange,
    members: [
        buffer_id {
            ty: u64,
            offset_v1: 0,
            offset_v2: 0,
        },
        offset {
            ty: u64,
            offset_v1: 8,
            offset_v2: 8,
        },
        size {
            ty: u64,
            offset_v1: 16,
            offset_v2: 16,
        },
    ],
    padding_v1: [],
    padding_v2: [],
    size_v1: 24,
    size_v2: 24,
    align_v1: 8,
    align_v2: 8,
}

/// A command buffer may be used to pass hardware instructions in a shared buffer (VMO).
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(C)]
pub struct CommandBuffer {
    /// Index of the resource containing instructions to start the command buffer.
    pub resource_index: u32,
    /// Starting offset within the resource.
    pub start_offset: u64,
}

impl fidl::encoding::TopLevel for CommandBuffer {}

impl fidl::encoding::Persistable for CommandBuffer {}

fidl_struct_copy! {
    name: CommandBuffer,
    members: [
        resource_index {
            ty: u32,
            offset_v1: 0,
            offset_v2: 0,
        },
        start_offset {
            ty: u64,
            offset_v1: 8,
            offset_v2: 8,
        },
    ],
    padding_v1: [
        {
            ty: u64,
            offset: 0,
            mask: 0xffffffff00000000u64,
        },],
    padding_v2: [
        {
            ty: u64,
            offset: 0,
            mask: 0xffffffff00000000u64,
        },],
    size_v1: 16,
    size_v2: 16,
    align_v1: 8,
    align_v2: 8,
}

/// Information about an ICD implementation that can be used with a Magma device.
#[derive(Debug, Clone, PartialEq)]
pub struct IcdInfo {
    /// URL of the component implementation that provides the ICD.
    pub component_url: Option<String>,
    /// Flags describing the basic capabilities of the ICD, including what APIs it supports.
    pub flags: Option<IcdFlags>,
    #[deprecated = "Use `..IcdInfo::EMPTY` to construct and `..` to match."]
    #[doc(hidden)]
    pub __non_exhaustive: (),
}

impl IcdInfo {
    /// An empty table with every field set to `None`.
    #[allow(deprecated)]
    pub const EMPTY: Self = Self { component_url: None, flags: None, __non_exhaustive: () };
}

impl fidl::encoding::TopLevel for IcdInfo {}

impl fidl::encoding::Persistable for IcdInfo {}

fidl_table! {
    name: IcdInfo,
    members: [
        component_url {
            ty: String,
            ordinal: 1,
        },
        flags {
            ty: IcdFlags,
            ordinal: 2,
        },
    ],
}

#[derive(Debug, Clone, PartialEq)]
pub struct PerformanceCounterEventsOnPerformanceCounterReadCompletedRequest {
    /// Required.
    pub trigger_id: Option<u32>,
    /// Required.
    pub buffer_id: Option<u64>,
    /// Required.
    pub buffer_offset: Option<u32>,
    /// Required.
    pub timestamp: Option<i64>,
    /// Required.
    pub flags: Option<ResultFlags>,
    #[deprecated = "Use `..PerformanceCounterEventsOnPerformanceCounterReadCompletedRequest::EMPTY` to construct and `..` to match."]
    #[doc(hidden)]
    pub __non_exhaustive: (),
}

impl PerformanceCounterEventsOnPerformanceCounterReadCompletedRequest {
    /// An empty table with every field set to `None`.
    #[allow(deprecated)]
    pub const EMPTY: Self = Self {
        trigger_id: None,
        buffer_id: None,
        buffer_offset: None,
        timestamp: None,
        flags: None,
        __non_exhaustive: (),
    };
}

impl fidl::encoding::TopLevel for PerformanceCounterEventsOnPerformanceCounterReadCompletedRequest {}

impl fidl::encoding::Persistable
    for PerformanceCounterEventsOnPerformanceCounterReadCompletedRequest
{
}

fidl_table! {
    name: PerformanceCounterEventsOnPerformanceCounterReadCompletedRequest,
    members: [
        trigger_id {
            ty: u32,
            ordinal: 1,
        },
        buffer_id {
            ty: u64,
            ordinal: 2,
        },
        buffer_offset {
            ty: u32,
            ordinal: 3,
        },
        timestamp {
            ty: i64,
            ordinal: 4,
        },
        flags {
            ty: ResultFlags,
            ordinal: 5,
        },
    ],
}

#[derive(Debug, Clone, PartialEq)]
pub struct PrimaryMapBufferRequest {
    /// Required.
    pub hw_va: Option<u64>,
    /// Required.
    pub range: Option<BufferRange>,
    pub flags: Option<MapFlags>,
    #[deprecated = "Use `..PrimaryMapBufferRequest::EMPTY` to construct and `..` to match."]
    #[doc(hidden)]
    pub __non_exhaustive: (),
}

impl PrimaryMapBufferRequest {
    /// An empty table with every field set to `None`.
    #[allow(deprecated)]
    pub const EMPTY: Self = Self { hw_va: None, range: None, flags: None, __non_exhaustive: () };
}

impl fidl::encoding::TopLevel for PrimaryMapBufferRequest {}

impl fidl::encoding::Persistable for PrimaryMapBufferRequest {}

fidl_table! {
    name: PrimaryMapBufferRequest,
    members: [
        hw_va {
            ty: u64,
            ordinal: 1,
        },
        range {
            ty: BufferRange,
            ordinal: 2,
        },
        flags {
            ty: MapFlags,
            ordinal: 3,
        },
    ],
}

#[derive(Debug, Clone, PartialEq)]
pub struct PrimaryUnmapBufferRequest {
    /// Required.
    pub hw_va: Option<u64>,
    /// Required.
    pub buffer_id: Option<u64>,
    #[deprecated = "Use `..PrimaryUnmapBufferRequest::EMPTY` to construct and `..` to match."]
    #[doc(hidden)]
    pub __non_exhaustive: (),
}

impl PrimaryUnmapBufferRequest {
    /// An empty table with every field set to `None`.
    #[allow(deprecated)]
    pub const EMPTY: Self = Self { hw_va: None, buffer_id: None, __non_exhaustive: () };
}

impl fidl::encoding::TopLevel for PrimaryUnmapBufferRequest {}

impl fidl::encoding::Persistable for PrimaryUnmapBufferRequest {}

fidl_table! {
    name: PrimaryUnmapBufferRequest,
    members: [
        hw_va {
            ty: u64,
            ordinal: 1,
        },
        buffer_id {
            ty: u64,
            ordinal: 2,
        },
    ],
}

wrap_handle_metadata!(
    HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT,
    fidl::ObjectType::CHANNEL,
    fidl::Rights::CHANNEL_DEFAULT
);

wrap_handle_metadata!(
    HandleWrapperObjectTypeEVENTRights2147483648,
    fidl::ObjectType::EVENT,
    fidl::Rights::from_bits_const(2147483648).unwrap()
);

wrap_handle_metadata!(
    HandleWrapperObjectTypeNONERights2147483648,
    fidl::ObjectType::NONE,
    fidl::Rights::from_bits_const(2147483648).unwrap()
);

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

impl fidl::endpoints::ProtocolMarker for CombinedDeviceMarker {
    type Proxy = CombinedDeviceProxy;
    type RequestStream = CombinedDeviceRequestStream;
    const DEBUG_NAME: &'static str = "(anonymous) CombinedDevice";
}

pub trait CombinedDeviceProxyInterface: Send + Sync {
    type QueryResponseFut: std::future::Future<Output = Result<(DeviceQueryResult), fidl::Error>>
        + Send;
    fn r#query(&self, query_id: QueryId) -> Self::QueryResponseFut;
    fn r#connect2(
        &self,
        client_id: u64,
        primary_channel: fidl::endpoints::ServerEnd<PrimaryMarker>,
        notification_channel: fidl::endpoints::ServerEnd<NotificationMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#dump_state(&self, dump_type: u32) -> Result<(), fidl::Error>;
    type GetIcdListResponseFut: std::future::Future<Output = Result<(Vec<IcdInfo>), fidl::Error>>
        + Send;
    fn r#get_icd_list(&self) -> Self::GetIcdListResponseFut;
}

#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct CombinedDeviceSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl CombinedDeviceSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <CombinedDeviceMarker 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::Time) -> Result<CombinedDeviceEvent, fidl::Error> {
        CombinedDeviceEvent::decode(self.client.wait_for_event(deadline)?)
    }
    /// On success, returns a result either in a buffer or a simple value.
    pub fn r#query(
        &self,
        mut query_id: QueryId,
        ___deadline: zx::Time,
    ) -> Result<(DeviceQueryResult), fidl::Error> {
        let _value: DeviceQueryResultHandleWrapper = self.client.send_query::<_, _, false, false>(
            &mut (query_id),
            0x627d4c6093b078e7,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_value.map(|_value| _value.0))
    }
    /// Creates a connection to the device comprised of two IPC channels.
    /// The primary channel is for the Primary protocol (see below).  The notification channel is
    /// used for vendor-specific messages which are sent only in the reverse (server-client)
    /// direction, typically in response to client command completion.
    pub fn r#connect2(
        &self,
        mut client_id: u64,
        mut primary_channel: fidl::endpoints::ServerEnd<PrimaryMarker>,
        mut notification_channel: fidl::endpoints::ServerEnd<NotificationMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (
                client_id,
                HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT::<
                    fidl::endpoints::ServerEnd<PrimaryMarker>,
                >(primary_channel),
                HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT::<
                    fidl::endpoints::ServerEnd<NotificationMarker>,
                >(notification_channel),
            ),
            0x3a5b134714c67914,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    /// Dumps driver and hardware state to the log.
    pub fn r#dump_state(&self, mut dump_type: u32) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (dump_type,),
            0x5420df493d4fa915,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    /// Returns a list of ICDs that can be used with this Magma device. The list is sorted in
    /// descending order of preference.
    pub fn r#get_icd_list(&self, ___deadline: zx::Time) -> Result<(Vec<IcdInfo>), fidl::Error> {
        let _value: (Vec<IcdInfo>,) = self.client.send_query::<_, _, false, true>(
            &mut (),
            0x7673e76395008257,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_value.0)
    }
}

#[derive(Debug, Clone)]
pub struct CombinedDeviceProxy {
    client: fidl::client::Client,
}

impl fidl::endpoints::Proxy for CombinedDeviceProxy {
    type Protocol = CombinedDeviceMarker;

    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 CombinedDeviceProxy {
    /// Create a new Proxy for CombinedDevice
    pub fn new(channel: fidl::AsyncChannel) -> Self {
        let protocol_name = <CombinedDeviceMarker 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 CombinedDevice protocol
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> CombinedDeviceEventStream {
        CombinedDeviceEventStream { event_receiver: self.client.take_event_receiver() }
    }
    /// On success, returns a result either in a buffer or a simple value.
    pub fn r#query(
        &self,
        mut query_id: QueryId,
    ) -> fidl::client::QueryResponseFut<(DeviceQueryResult)> {
        CombinedDeviceProxyInterface::r#query(self, query_id)
    }
    /// Creates a connection to the device comprised of two IPC channels.
    /// The primary channel is for the Primary protocol (see below).  The notification channel is
    /// used for vendor-specific messages which are sent only in the reverse (server-client)
    /// direction, typically in response to client command completion.
    pub fn r#connect2(
        &self,
        mut client_id: u64,
        mut primary_channel: fidl::endpoints::ServerEnd<PrimaryMarker>,
        mut notification_channel: fidl::endpoints::ServerEnd<NotificationMarker>,
    ) -> Result<(), fidl::Error> {
        CombinedDeviceProxyInterface::r#connect2(
            self,
            client_id,
            primary_channel,
            notification_channel,
        )
    }
    /// Dumps driver and hardware state to the log.
    pub fn r#dump_state(&self, mut dump_type: u32) -> Result<(), fidl::Error> {
        CombinedDeviceProxyInterface::r#dump_state(self, dump_type)
    }
    /// Returns a list of ICDs that can be used with this Magma device. The list is sorted in
    /// descending order of preference.
    pub fn r#get_icd_list(&self) -> fidl::client::QueryResponseFut<(Vec<IcdInfo>)> {
        CombinedDeviceProxyInterface::r#get_icd_list(self)
    }
}

impl CombinedDeviceProxyInterface for CombinedDeviceProxy {
    type QueryResponseFut = fidl::client::QueryResponseFut<(DeviceQueryResult)>;
    fn r#query(&self, mut query_id: QueryId) -> Self::QueryResponseFut {
        fn transform(
            result: Result<DeviceQueryResultHandleWrapper, fidl::Error>,
        ) -> Result<(DeviceQueryResult), fidl::Error> {
            result.map(|_value| _value.map(|_value| _value.0))
        }
        let send_result = self.client.call_send_raw_query::<_, false>(
            &mut (query_id),
            0x627d4c6093b078e7,
            fidl::encoding::DynamicFlags::empty(),
        );
        QueryResponseFut(match send_result {
            Ok(res_fut) => future::maybe_done(
                res_fut.and_then(|buf| decode_transaction_body_fut::<_, _, false>(buf, transform)),
            ),
            Err(e) => MaybeDone::Done(Err(e)),
        })
    }
    fn r#connect2(
        &self,
        mut client_id: u64,
        mut primary_channel: fidl::endpoints::ServerEnd<PrimaryMarker>,
        mut notification_channel: fidl::endpoints::ServerEnd<NotificationMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (
                client_id,
                HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT::<
                    fidl::endpoints::ServerEnd<PrimaryMarker>,
                >(primary_channel),
                HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT::<
                    fidl::endpoints::ServerEnd<NotificationMarker>,
                >(notification_channel),
            ),
            0x3a5b134714c67914,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    fn r#dump_state(&self, mut dump_type: u32) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (dump_type),
            0x5420df493d4fa915,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    type GetIcdListResponseFut = fidl::client::QueryResponseFut<(Vec<IcdInfo>)>;
    fn r#get_icd_list(&self) -> Self::GetIcdListResponseFut {
        fn transform(
            result: Result<(Vec<IcdInfo>,), fidl::Error>,
        ) -> Result<(Vec<IcdInfo>), fidl::Error> {
            result.map(|_value| _value.0)
        }
        let send_result = self.client.call_send_raw_query::<_, false>(
            &mut (),
            0x7673e76395008257,
            fidl::encoding::DynamicFlags::empty(),
        );
        QueryResponseFut(match send_result {
            Ok(res_fut) => future::maybe_done(
                res_fut.and_then(|buf| decode_transaction_body_fut::<_, _, true>(buf, transform)),
            ),
            Err(e) => MaybeDone::Done(Err(e)),
        })
    }
}

pub struct CombinedDeviceEventStream {
    event_receiver: fidl::client::EventReceiver,
}

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

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

impl futures::Stream for CombinedDeviceEventStream {
    type Item = Result<CombinedDeviceEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let buf = match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => buf,
            None => return std::task::Poll::Ready(None),
        };

        std::task::Poll::Ready(Some(CombinedDeviceEvent::decode(buf)))
    }
}

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

impl CombinedDeviceEvent {
    /// Decodes a message buffer as a [`CombinedDeviceEvent`]. Transaction
    /// ID in the message must be zero; this method does not check TXID.
    fn decode(mut buf: fidl::MessageBufEtc) -> Result<CombinedDeviceEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

        match tx_header.ordinal() {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal(),
                protocol_name:
                    <CombinedDeviceMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for CombinedDevice
pub struct CombinedDeviceRequestStream {
    inner: std::sync::Arc<fidl::ServeInner>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for CombinedDeviceRequestStream {
    type Protocol = CombinedDeviceMarker;
    type ControlHandle = CombinedDeviceControlHandle;

    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 {
        CombinedDeviceControlHandle { inner: self.inner.clone() }
    }

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

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

impl futures::Stream for CombinedDeviceRequestStream {
    type Item = Result<CombinedDeviceRequest, 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.poll_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled CombinedDeviceRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf(|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))))
                }
            }

            // A message has been received from the channel
            let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
            if !header.is_compatible() {
                return std::task::Poll::Ready(Some(Err(fidl::Error::IncompatibleMagicNumber(
                    header.magic_number(),
                ))));
            }

            std::task::Poll::Ready(Some(match header.ordinal() {
                0x627d4c6093b078e7 => {
                    let mut req: (QueryId,) = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/CombinedDeviceQueryRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = CombinedDeviceControlHandle { inner: this.inner.clone() };

                    Ok(CombinedDeviceRequest::Query {
                        query_id: req.0,
                        responder: CombinedDeviceQueryResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id(),
                            ordinal: header.ordinal(),
                        },
                    })
                }
                0x3a5b134714c67914 => {
                    let mut req: (
                        u64,
                        HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT<
                            fidl::endpoints::ServerEnd<PrimaryMarker>,
                        >,
                        HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT<
                            fidl::endpoints::ServerEnd<NotificationMarker>,
                        >,
                    ) = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/CombinedDeviceConnect2Request");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = CombinedDeviceControlHandle { inner: this.inner.clone() };

                    Ok(CombinedDeviceRequest::Connect2 {
                        client_id: req.0,
                        primary_channel: req.1.into_inner(),
                        notification_channel: req.2.into_inner(),
                        control_handle,
                    })
                }
                0x5420df493d4fa915 => {
                    let mut req: (u32,) = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/CombinedDeviceDumpStateRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = CombinedDeviceControlHandle { inner: this.inner.clone() };

                    Ok(CombinedDeviceRequest::DumpState { dump_type: req.0, control_handle })
                }
                0x7673e76395008257 => {
                    let mut req: () = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/CombinedDeviceGetIcdListRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = CombinedDeviceControlHandle { inner: this.inner.clone() };

                    Ok(CombinedDeviceRequest::GetIcdList {
                        responder: CombinedDeviceGetIcdListResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id(),
                            ordinal: header.ordinal(),
                        },
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal(),
                    protocol_name:
                        <CombinedDeviceMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
        })
    }
}
/// A combination of all the production |Device| protocols. This protocol is implemented on the
/// Magma service side and should not be used by clients.
#[derive(Debug)]
pub enum CombinedDeviceRequest {
    /// On success, returns a result either in a buffer or a simple value.
    Query { query_id: QueryId, responder: CombinedDeviceQueryResponder },
    /// Creates a connection to the device comprised of two IPC channels.
    /// The primary channel is for the Primary protocol (see below).  The notification channel is
    /// used for vendor-specific messages which are sent only in the reverse (server-client)
    /// direction, typically in response to client command completion.
    Connect2 {
        client_id: u64,

        primary_channel: fidl::endpoints::ServerEnd<PrimaryMarker>,

        notification_channel: fidl::endpoints::ServerEnd<NotificationMarker>,
        control_handle: CombinedDeviceControlHandle,
    },
    /// Dumps driver and hardware state to the log.
    DumpState { dump_type: u32, control_handle: CombinedDeviceControlHandle },
    /// Returns a list of ICDs that can be used with this Magma device. The list is sorted in
    /// descending order of preference.
    GetIcdList { responder: CombinedDeviceGetIcdListResponder },
}

impl CombinedDeviceRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_query(self) -> Option<(QueryId, CombinedDeviceQueryResponder)> {
        if let CombinedDeviceRequest::Query { query_id, responder } = self {
            Some((query_id, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_connect2(
        self,
    ) -> Option<(
        u64,
        fidl::endpoints::ServerEnd<PrimaryMarker>,
        fidl::endpoints::ServerEnd<NotificationMarker>,
        CombinedDeviceControlHandle,
    )> {
        if let CombinedDeviceRequest::Connect2 {
            client_id,

            primary_channel,

            notification_channel,
            control_handle,
        } = self
        {
            Some((client_id, primary_channel, notification_channel, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_dump_state(self) -> Option<(u32, CombinedDeviceControlHandle)> {
        if let CombinedDeviceRequest::DumpState { dump_type, control_handle } = self {
            Some((dump_type, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_icd_list(self) -> Option<(CombinedDeviceGetIcdListResponder)> {
        if let CombinedDeviceRequest::GetIcdList { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            CombinedDeviceRequest::Query { .. } => "query",
            CombinedDeviceRequest::Connect2 { .. } => "connect2",
            CombinedDeviceRequest::DumpState { .. } => "dump_state",
            CombinedDeviceRequest::GetIcdList { .. } => "get_icd_list",
        }
    }
}

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

impl fidl::endpoints::ControlHandle for CombinedDeviceControlHandle {
    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<'a>(&'a self) -> fidl::OnSignals<'a> {
        self.inner.channel().on_closed()
    }
}

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

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

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

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

    fn send_raw(&self, mut _result: &mut DeviceQueryResult) -> Result<(), fidl::Error> {
        let mut response = (_result);

        let mut msg = fidl::encoding::TransactionMessage {
            header: fidl::encoding::TransactionHeader::new(
                self.tx_id,
                self.ordinal,
                fidl::encoding::DynamicFlags::empty(),
            ),
            body: &mut response,
        };

        fidl::encoding::with_tls_encode_buf(|bytes, handles| {
            fidl::duration_begin!("fidl", "encode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/CombinedDeviceQueryResponse");
            fidl::encoding::Encoder::encode(bytes, handles, &mut msg)?;
            fidl::trace_blob!("fidl:blob", "encode", bytes.as_slice());
            fidl::duration_end!("fidl", "encode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);

            self.control_handle.inner.send_raw_msg(&*bytes, &mut *handles)
        })
    }
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct CombinedDeviceGetIcdListResponder {
    control_handle: std::mem::ManuallyDrop<CombinedDeviceControlHandle>,
    tx_id: u32,
    ordinal: u64,
}

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

    fn control_handle(&self) -> &CombinedDeviceControlHandle {
        &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 CombinedDeviceGetIcdListResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut icd_list: &mut dyn ExactSizeIterator<Item = IcdInfo>,
    ) -> Result<(), fidl::Error> {
        let r = self.send_raw(icd_list);
        if r.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        r
    }

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

    fn send_raw(
        &self,
        mut icd_list: &mut dyn ExactSizeIterator<Item = IcdInfo>,
    ) -> Result<(), fidl::Error> {
        let mut response = (icd_list);

        let mut msg = fidl::encoding::TransactionMessage {
            header: fidl::encoding::TransactionHeader::new(
                self.tx_id,
                self.ordinal,
                fidl::encoding::DynamicFlags::empty(),
            ),
            body: &mut response,
        };

        fidl::encoding::with_tls_encode_buf(|bytes, handles| {
            fidl::duration_begin!("fidl", "encode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/CombinedDeviceGetIcdListResponse");
            fidl::encoding::Encoder::encode(bytes, handles, &mut msg)?;
            fidl::trace_blob!("fidl:blob", "encode", bytes.as_slice());
            fidl::duration_end!("fidl", "encode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);

            self.control_handle.inner.send_raw_msg(&*bytes, &mut *handles)
        })
    }
}

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

impl fidl::endpoints::ProtocolMarker for DependencyInjectionMarker {
    type Proxy = DependencyInjectionProxy;
    type RequestStream = DependencyInjectionRequestStream;
    const DEBUG_NAME: &'static str = "(anonymous) DependencyInjection";
}

pub trait DependencyInjectionProxyInterface: Send + Sync {
    fn r#set_memory_pressure_provider(
        &self,
        provider: fidl::endpoints::ClientEnd<fidl_fuchsia_memorypressure::ProviderMarker>,
    ) -> Result<(), fidl::Error>;
}

#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct DependencyInjectionSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl DependencyInjectionSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <DependencyInjectionMarker 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::Time,
    ) -> Result<DependencyInjectionEvent, fidl::Error> {
        DependencyInjectionEvent::decode(self.client.wait_for_event(deadline)?)
    }
    /// Provides a `fuchsia.memorypressure.Provider` implementation to the MSD.
    pub fn r#set_memory_pressure_provider(
        &self,
        mut provider: fidl::endpoints::ClientEnd<fidl_fuchsia_memorypressure::ProviderMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT::<
                fidl::endpoints::ClientEnd<fidl_fuchsia_memorypressure::ProviderMarker>,
            >(provider),),
            0x5ef0be960d4b0f4c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[derive(Debug, Clone)]
pub struct DependencyInjectionProxy {
    client: fidl::client::Client,
}

impl fidl::endpoints::Proxy for DependencyInjectionProxy {
    type Protocol = DependencyInjectionMarker;

    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 DependencyInjectionProxy {
    /// Create a new Proxy for DependencyInjection
    pub fn new(channel: fidl::AsyncChannel) -> Self {
        let protocol_name =
            <DependencyInjectionMarker 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 DependencyInjection protocol
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> DependencyInjectionEventStream {
        DependencyInjectionEventStream { event_receiver: self.client.take_event_receiver() }
    }
    /// Provides a `fuchsia.memorypressure.Provider` implementation to the MSD.
    pub fn r#set_memory_pressure_provider(
        &self,
        mut provider: fidl::endpoints::ClientEnd<fidl_fuchsia_memorypressure::ProviderMarker>,
    ) -> Result<(), fidl::Error> {
        DependencyInjectionProxyInterface::r#set_memory_pressure_provider(self, provider)
    }
}

impl DependencyInjectionProxyInterface for DependencyInjectionProxy {
    fn r#set_memory_pressure_provider(
        &self,
        mut provider: fidl::endpoints::ClientEnd<fidl_fuchsia_memorypressure::ProviderMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT::<
                fidl::endpoints::ClientEnd<fidl_fuchsia_memorypressure::ProviderMarker>,
            >(provider)),
            0x5ef0be960d4b0f4c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

pub struct DependencyInjectionEventStream {
    event_receiver: fidl::client::EventReceiver,
}

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

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

impl futures::Stream for DependencyInjectionEventStream {
    type Item = Result<DependencyInjectionEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let buf = match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => buf,
            None => return std::task::Poll::Ready(None),
        };

        std::task::Poll::Ready(Some(DependencyInjectionEvent::decode(buf)))
    }
}

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

impl DependencyInjectionEvent {
    /// Decodes a message buffer as a [`DependencyInjectionEvent`]. Transaction
    /// ID in the message must be zero; this method does not check TXID.
    fn decode(mut buf: fidl::MessageBufEtc) -> Result<DependencyInjectionEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

        match tx_header.ordinal() {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal(),
                protocol_name:
                    <DependencyInjectionMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for DependencyInjection
pub struct DependencyInjectionRequestStream {
    inner: std::sync::Arc<fidl::ServeInner>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for DependencyInjectionRequestStream {
    type Protocol = DependencyInjectionMarker;
    type ControlHandle = DependencyInjectionControlHandle;

    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 {
        DependencyInjectionControlHandle { inner: self.inner.clone() }
    }

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

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

impl futures::Stream for DependencyInjectionRequestStream {
    type Item = Result<DependencyInjectionRequest, 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.poll_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled DependencyInjectionRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf(|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))))
                }
            }

            // A message has been received from the channel
            let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
            if !header.is_compatible() {
                return std::task::Poll::Ready(Some(Err(fidl::Error::IncompatibleMagicNumber(
                    header.magic_number(),
                ))));
            }

            std::task::Poll::Ready(Some(match header.ordinal() {
                0x5ef0be960d4b0f4c => {
                    let mut req: (
                        HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT<
                            fidl::endpoints::ClientEnd<fidl_fuchsia_memorypressure::ProviderMarker>,
                        >,
                    ) = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/DependencyInjectionSetMemoryPressureProviderRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle =
                        DependencyInjectionControlHandle { inner: this.inner.clone() };

                    Ok(DependencyInjectionRequest::SetMemoryPressureProvider {
                        provider: req.0.into_inner(),
                        control_handle,
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal(),
                    protocol_name:
                        <DependencyInjectionMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
        })
    }
}
/// This protocol is implemented by ZX_PROTOCOL_GPU_DEPENDENCY_INJECTION devices. It's used
/// to inject dependencies on other services into the MSD. It can be used
/// only by a privileged process.
#[derive(Debug)]
pub enum DependencyInjectionRequest {
    /// Provides a `fuchsia.memorypressure.Provider` implementation to the MSD.
    SetMemoryPressureProvider {
        provider: fidl::endpoints::ClientEnd<fidl_fuchsia_memorypressure::ProviderMarker>,
        control_handle: DependencyInjectionControlHandle,
    },
}

impl DependencyInjectionRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_set_memory_pressure_provider(
        self,
    ) -> Option<(
        fidl::endpoints::ClientEnd<fidl_fuchsia_memorypressure::ProviderMarker>,
        DependencyInjectionControlHandle,
    )> {
        if let DependencyInjectionRequest::SetMemoryPressureProvider { provider, control_handle } =
            self
        {
            Some((provider, control_handle))
        } else {
            None
        }
    }

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

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

impl fidl::endpoints::ControlHandle for DependencyInjectionControlHandle {
    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<'a>(&'a self) -> fidl::OnSignals<'a> {
        self.inner.channel().on_closed()
    }
}

impl DependencyInjectionControlHandle {}

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

impl fidl::endpoints::ProtocolMarker for DeviceMarker {
    type Proxy = DeviceProxy;
    type RequestStream = DeviceRequestStream;
    const DEBUG_NAME: &'static str = "(anonymous) Device";
}

pub trait DeviceProxyInterface: Send + Sync {
    type QueryResponseFut: std::future::Future<Output = Result<(DeviceQueryResult), fidl::Error>>
        + Send;
    fn r#query(&self, query_id: QueryId) -> Self::QueryResponseFut;
    fn r#connect2(
        &self,
        client_id: u64,
        primary_channel: fidl::endpoints::ServerEnd<PrimaryMarker>,
        notification_channel: fidl::endpoints::ServerEnd<NotificationMarker>,
    ) -> Result<(), fidl::Error>;
}

#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct DeviceSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl DeviceSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <DeviceMarker 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::Time) -> Result<DeviceEvent, fidl::Error> {
        DeviceEvent::decode(self.client.wait_for_event(deadline)?)
    }
    /// On success, returns a result either in a buffer or a simple value.
    pub fn r#query(
        &self,
        mut query_id: QueryId,
        ___deadline: zx::Time,
    ) -> Result<(DeviceQueryResult), fidl::Error> {
        let _value: DeviceQueryResultHandleWrapper = self.client.send_query::<_, _, false, false>(
            &mut (query_id),
            0x627d4c6093b078e7,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_value.map(|_value| _value.0))
    }
    /// Creates a connection to the device comprised of two IPC channels.
    /// The primary channel is for the Primary protocol (see below).  The notification channel is
    /// used for vendor-specific messages which are sent only in the reverse (server-client)
    /// direction, typically in response to client command completion.
    pub fn r#connect2(
        &self,
        mut client_id: u64,
        mut primary_channel: fidl::endpoints::ServerEnd<PrimaryMarker>,
        mut notification_channel: fidl::endpoints::ServerEnd<NotificationMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (
                client_id,
                HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT::<
                    fidl::endpoints::ServerEnd<PrimaryMarker>,
                >(primary_channel),
                HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT::<
                    fidl::endpoints::ServerEnd<NotificationMarker>,
                >(notification_channel),
            ),
            0x3a5b134714c67914,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[derive(Debug, Clone)]
pub struct DeviceProxy {
    client: fidl::client::Client,
}

impl fidl::endpoints::Proxy for DeviceProxy {
    type Protocol = DeviceMarker;

    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 DeviceProxy {
    /// Create a new Proxy for Device
    pub fn new(channel: fidl::AsyncChannel) -> Self {
        let protocol_name = <DeviceMarker 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 Device protocol
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> DeviceEventStream {
        DeviceEventStream { event_receiver: self.client.take_event_receiver() }
    }
    /// On success, returns a result either in a buffer or a simple value.
    pub fn r#query(
        &self,
        mut query_id: QueryId,
    ) -> fidl::client::QueryResponseFut<(DeviceQueryResult)> {
        DeviceProxyInterface::r#query(self, query_id)
    }
    /// Creates a connection to the device comprised of two IPC channels.
    /// The primary channel is for the Primary protocol (see below).  The notification channel is
    /// used for vendor-specific messages which are sent only in the reverse (server-client)
    /// direction, typically in response to client command completion.
    pub fn r#connect2(
        &self,
        mut client_id: u64,
        mut primary_channel: fidl::endpoints::ServerEnd<PrimaryMarker>,
        mut notification_channel: fidl::endpoints::ServerEnd<NotificationMarker>,
    ) -> Result<(), fidl::Error> {
        DeviceProxyInterface::r#connect2(self, client_id, primary_channel, notification_channel)
    }
}

impl DeviceProxyInterface for DeviceProxy {
    type QueryResponseFut = fidl::client::QueryResponseFut<(DeviceQueryResult)>;
    fn r#query(&self, mut query_id: QueryId) -> Self::QueryResponseFut {
        fn transform(
            result: Result<DeviceQueryResultHandleWrapper, fidl::Error>,
        ) -> Result<(DeviceQueryResult), fidl::Error> {
            result.map(|_value| _value.map(|_value| _value.0))
        }
        let send_result = self.client.call_send_raw_query::<_, false>(
            &mut (query_id),
            0x627d4c6093b078e7,
            fidl::encoding::DynamicFlags::empty(),
        );
        QueryResponseFut(match send_result {
            Ok(res_fut) => future::maybe_done(
                res_fut.and_then(|buf| decode_transaction_body_fut::<_, _, false>(buf, transform)),
            ),
            Err(e) => MaybeDone::Done(Err(e)),
        })
    }
    fn r#connect2(
        &self,
        mut client_id: u64,
        mut primary_channel: fidl::endpoints::ServerEnd<PrimaryMarker>,
        mut notification_channel: fidl::endpoints::ServerEnd<NotificationMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (
                client_id,
                HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT::<
                    fidl::endpoints::ServerEnd<PrimaryMarker>,
                >(primary_channel),
                HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT::<
                    fidl::endpoints::ServerEnd<NotificationMarker>,
                >(notification_channel),
            ),
            0x3a5b134714c67914,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

pub struct DeviceEventStream {
    event_receiver: fidl::client::EventReceiver,
}

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

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

impl futures::Stream for DeviceEventStream {
    type Item = Result<DeviceEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let buf = match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => buf,
            None => return std::task::Poll::Ready(None),
        };

        std::task::Poll::Ready(Some(DeviceEvent::decode(buf)))
    }
}

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

impl DeviceEvent {
    /// Decodes a message buffer as a [`DeviceEvent`]. Transaction
    /// ID in the message must be zero; this method does not check TXID.
    fn decode(mut buf: fidl::MessageBufEtc) -> Result<DeviceEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

        match tx_header.ordinal() {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal(),
                protocol_name: <DeviceMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for Device
pub struct DeviceRequestStream {
    inner: std::sync::Arc<fidl::ServeInner>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for DeviceRequestStream {
    type Protocol = DeviceMarker;
    type ControlHandle = DeviceControlHandle;

    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 {
        DeviceControlHandle { inner: self.inner.clone() }
    }

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

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

impl futures::Stream for DeviceRequestStream {
    type Item = Result<DeviceRequest, 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.poll_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled DeviceRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf(|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))))
                }
            }

            // A message has been received from the channel
            let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
            if !header.is_compatible() {
                return std::task::Poll::Ready(Some(Err(fidl::Error::IncompatibleMagicNumber(
                    header.magic_number(),
                ))));
            }

            std::task::Poll::Ready(Some(match header.ordinal() {
                0x627d4c6093b078e7 => {
                    let mut req: (QueryId,) = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/DeviceQueryRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = DeviceControlHandle { inner: this.inner.clone() };

                    Ok(DeviceRequest::Query {
                        query_id: req.0,
                        responder: DeviceQueryResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id(),
                            ordinal: header.ordinal(),
                        },
                    })
                }
                0x3a5b134714c67914 => {
                    let mut req: (
                        u64,
                        HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT<
                            fidl::endpoints::ServerEnd<PrimaryMarker>,
                        >,
                        HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT<
                            fidl::endpoints::ServerEnd<NotificationMarker>,
                        >,
                    ) = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/DeviceConnect2Request");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = DeviceControlHandle { inner: this.inner.clone() };

                    Ok(DeviceRequest::Connect2 {
                        client_id: req.0,
                        primary_channel: req.1.into_inner(),
                        notification_channel: req.2.into_inner(),
                        control_handle,
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal(),
                    protocol_name: <DeviceMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
        })
    }
}
/// The Magma Device protocol allow clients to learn about the hardware by making queries, such as
/// device and vendor IDs, and which client drivers are supported by the device's system driver.  
/// To engage further with the device, clients may establish connections formed of channel pairs:
/// a primary channel for making requests (see Primary protocol below), and a secondary channel
/// for receiving notification messages (see Notification protocol below).
#[derive(Debug)]
pub enum DeviceRequest {
    /// On success, returns a result either in a buffer or a simple value.
    Query { query_id: QueryId, responder: DeviceQueryResponder },
    /// Creates a connection to the device comprised of two IPC channels.
    /// The primary channel is for the Primary protocol (see below).  The notification channel is
    /// used for vendor-specific messages which are sent only in the reverse (server-client)
    /// direction, typically in response to client command completion.
    Connect2 {
        client_id: u64,

        primary_channel: fidl::endpoints::ServerEnd<PrimaryMarker>,

        notification_channel: fidl::endpoints::ServerEnd<NotificationMarker>,
        control_handle: DeviceControlHandle,
    },
}

impl DeviceRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_query(self) -> Option<(QueryId, DeviceQueryResponder)> {
        if let DeviceRequest::Query { query_id, responder } = self {
            Some((query_id, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_connect2(
        self,
    ) -> Option<(
        u64,
        fidl::endpoints::ServerEnd<PrimaryMarker>,
        fidl::endpoints::ServerEnd<NotificationMarker>,
        DeviceControlHandle,
    )> {
        if let DeviceRequest::Connect2 {
            client_id,

            primary_channel,

            notification_channel,
            control_handle,
        } = self
        {
            Some((client_id, primary_channel, notification_channel, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            DeviceRequest::Query { .. } => "query",
            DeviceRequest::Connect2 { .. } => "connect2",
        }
    }
}

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

impl fidl::endpoints::ControlHandle for DeviceControlHandle {
    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<'a>(&'a self) -> fidl::OnSignals<'a> {
        self.inner.channel().on_closed()
    }
}

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

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

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

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

    fn send_raw(&self, mut _result: &mut DeviceQueryResult) -> Result<(), fidl::Error> {
        let mut response = (_result);

        let mut msg = fidl::encoding::TransactionMessage {
            header: fidl::encoding::TransactionHeader::new(
                self.tx_id,
                self.ordinal,
                fidl::encoding::DynamicFlags::empty(),
            ),
            body: &mut response,
        };

        fidl::encoding::with_tls_encode_buf(|bytes, handles| {
            fidl::duration_begin!("fidl", "encode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/DeviceQueryResponse");
            fidl::encoding::Encoder::encode(bytes, handles, &mut msg)?;
            fidl::trace_blob!("fidl:blob", "encode", bytes.as_slice());
            fidl::duration_end!("fidl", "encode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);

            self.control_handle.inner.send_raw_msg(&*bytes, &mut *handles)
        })
    }
}

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

impl fidl::endpoints::ProtocolMarker for DiagnosticDeviceMarker {
    type Proxy = DiagnosticDeviceProxy;
    type RequestStream = DiagnosticDeviceRequestStream;
    const DEBUG_NAME: &'static str = "(anonymous) DiagnosticDevice";
}

pub trait DiagnosticDeviceProxyInterface: Send + Sync {
    fn r#dump_state(&self, dump_type: u32) -> Result<(), fidl::Error>;
}

#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct DiagnosticDeviceSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl DiagnosticDeviceSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <DiagnosticDeviceMarker 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::Time) -> Result<DiagnosticDeviceEvent, fidl::Error> {
        DiagnosticDeviceEvent::decode(self.client.wait_for_event(deadline)?)
    }
    /// Dumps driver and hardware state to the log.
    pub fn r#dump_state(&self, mut dump_type: u32) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (dump_type,),
            0x5420df493d4fa915,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[derive(Debug, Clone)]
pub struct DiagnosticDeviceProxy {
    client: fidl::client::Client,
}

impl fidl::endpoints::Proxy for DiagnosticDeviceProxy {
    type Protocol = DiagnosticDeviceMarker;

    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 DiagnosticDeviceProxy {
    /// Create a new Proxy for DiagnosticDevice
    pub fn new(channel: fidl::AsyncChannel) -> Self {
        let protocol_name = <DiagnosticDeviceMarker 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 DiagnosticDevice protocol
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> DiagnosticDeviceEventStream {
        DiagnosticDeviceEventStream { event_receiver: self.client.take_event_receiver() }
    }
    /// Dumps driver and hardware state to the log.
    pub fn r#dump_state(&self, mut dump_type: u32) -> Result<(), fidl::Error> {
        DiagnosticDeviceProxyInterface::r#dump_state(self, dump_type)
    }
}

impl DiagnosticDeviceProxyInterface for DiagnosticDeviceProxy {
    fn r#dump_state(&self, mut dump_type: u32) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (dump_type),
            0x5420df493d4fa915,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

pub struct DiagnosticDeviceEventStream {
    event_receiver: fidl::client::EventReceiver,
}

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

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

impl futures::Stream for DiagnosticDeviceEventStream {
    type Item = Result<DiagnosticDeviceEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let buf = match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => buf,
            None => return std::task::Poll::Ready(None),
        };

        std::task::Poll::Ready(Some(DiagnosticDeviceEvent::decode(buf)))
    }
}

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

impl DiagnosticDeviceEvent {
    /// Decodes a message buffer as a [`DiagnosticDeviceEvent`]. Transaction
    /// ID in the message must be zero; this method does not check TXID.
    fn decode(mut buf: fidl::MessageBufEtc) -> Result<DiagnosticDeviceEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

        match tx_header.ordinal() {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal(),
                protocol_name:
                    <DiagnosticDeviceMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for DiagnosticDevice
pub struct DiagnosticDeviceRequestStream {
    inner: std::sync::Arc<fidl::ServeInner>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for DiagnosticDeviceRequestStream {
    type Protocol = DiagnosticDeviceMarker;
    type ControlHandle = DiagnosticDeviceControlHandle;

    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 {
        DiagnosticDeviceControlHandle { inner: self.inner.clone() }
    }

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

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

impl futures::Stream for DiagnosticDeviceRequestStream {
    type Item = Result<DiagnosticDeviceRequest, 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.poll_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled DiagnosticDeviceRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf(|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))))
                }
            }

            // A message has been received from the channel
            let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
            if !header.is_compatible() {
                return std::task::Poll::Ready(Some(Err(fidl::Error::IncompatibleMagicNumber(
                    header.magic_number(),
                ))));
            }

            std::task::Poll::Ready(Some(match header.ordinal() {
                0x5420df493d4fa915 => {
                    let mut req: (u32,) = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/DiagnosticDeviceDumpStateRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle =
                        DiagnosticDeviceControlHandle { inner: this.inner.clone() };

                    Ok(DiagnosticDeviceRequest::DumpState { dump_type: req.0, control_handle })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal(),
                    protocol_name:
                        <DiagnosticDeviceMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
        })
    }
}
/// Methods used to expose diagnostics from the Magma device.
#[derive(Debug)]
pub enum DiagnosticDeviceRequest {
    /// Dumps driver and hardware state to the log.
    DumpState { dump_type: u32, control_handle: DiagnosticDeviceControlHandle },
}

impl DiagnosticDeviceRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_dump_state(self) -> Option<(u32, DiagnosticDeviceControlHandle)> {
        if let DiagnosticDeviceRequest::DumpState { dump_type, control_handle } = self {
            Some((dump_type, control_handle))
        } else {
            None
        }
    }

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

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

impl fidl::endpoints::ControlHandle for DiagnosticDeviceControlHandle {
    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<'a>(&'a self) -> fidl::OnSignals<'a> {
        self.inner.channel().on_closed()
    }
}

impl DiagnosticDeviceControlHandle {}

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

impl fidl::endpoints::ProtocolMarker for IcdLoaderDeviceMarker {
    type Proxy = IcdLoaderDeviceProxy;
    type RequestStream = IcdLoaderDeviceRequestStream;
    const DEBUG_NAME: &'static str = "(anonymous) IcdLoaderDevice";
}

pub trait IcdLoaderDeviceProxyInterface: Send + Sync {
    type GetIcdListResponseFut: std::future::Future<Output = Result<(Vec<IcdInfo>), fidl::Error>>
        + Send;
    fn r#get_icd_list(&self) -> Self::GetIcdListResponseFut;
}

#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct IcdLoaderDeviceSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl IcdLoaderDeviceSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <IcdLoaderDeviceMarker 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::Time) -> Result<IcdLoaderDeviceEvent, fidl::Error> {
        IcdLoaderDeviceEvent::decode(self.client.wait_for_event(deadline)?)
    }
    /// Returns a list of ICDs that can be used with this Magma device. The list is sorted in
    /// descending order of preference.
    pub fn r#get_icd_list(&self, ___deadline: zx::Time) -> Result<(Vec<IcdInfo>), fidl::Error> {
        let _value: (Vec<IcdInfo>,) = self.client.send_query::<_, _, false, true>(
            &mut (),
            0x7673e76395008257,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_value.0)
    }
}

#[derive(Debug, Clone)]
pub struct IcdLoaderDeviceProxy {
    client: fidl::client::Client,
}

impl fidl::endpoints::Proxy for IcdLoaderDeviceProxy {
    type Protocol = IcdLoaderDeviceMarker;

    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 IcdLoaderDeviceProxy {
    /// Create a new Proxy for IcdLoaderDevice
    pub fn new(channel: fidl::AsyncChannel) -> Self {
        let protocol_name = <IcdLoaderDeviceMarker 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 IcdLoaderDevice protocol
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> IcdLoaderDeviceEventStream {
        IcdLoaderDeviceEventStream { event_receiver: self.client.take_event_receiver() }
    }
    /// Returns a list of ICDs that can be used with this Magma device. The list is sorted in
    /// descending order of preference.
    pub fn r#get_icd_list(&self) -> fidl::client::QueryResponseFut<(Vec<IcdInfo>)> {
        IcdLoaderDeviceProxyInterface::r#get_icd_list(self)
    }
}

impl IcdLoaderDeviceProxyInterface for IcdLoaderDeviceProxy {
    type GetIcdListResponseFut = fidl::client::QueryResponseFut<(Vec<IcdInfo>)>;
    fn r#get_icd_list(&self) -> Self::GetIcdListResponseFut {
        fn transform(
            result: Result<(Vec<IcdInfo>,), fidl::Error>,
        ) -> Result<(Vec<IcdInfo>), fidl::Error> {
            result.map(|_value| _value.0)
        }
        let send_result = self.client.call_send_raw_query::<_, false>(
            &mut (),
            0x7673e76395008257,
            fidl::encoding::DynamicFlags::empty(),
        );
        QueryResponseFut(match send_result {
            Ok(res_fut) => future::maybe_done(
                res_fut.and_then(|buf| decode_transaction_body_fut::<_, _, true>(buf, transform)),
            ),
            Err(e) => MaybeDone::Done(Err(e)),
        })
    }
}

pub struct IcdLoaderDeviceEventStream {
    event_receiver: fidl::client::EventReceiver,
}

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

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

impl futures::Stream for IcdLoaderDeviceEventStream {
    type Item = Result<IcdLoaderDeviceEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let buf = match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => buf,
            None => return std::task::Poll::Ready(None),
        };

        std::task::Poll::Ready(Some(IcdLoaderDeviceEvent::decode(buf)))
    }
}

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

impl IcdLoaderDeviceEvent {
    /// Decodes a message buffer as a [`IcdLoaderDeviceEvent`]. Transaction
    /// ID in the message must be zero; this method does not check TXID.
    fn decode(mut buf: fidl::MessageBufEtc) -> Result<IcdLoaderDeviceEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

        match tx_header.ordinal() {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal(),
                protocol_name:
                    <IcdLoaderDeviceMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for IcdLoaderDevice
pub struct IcdLoaderDeviceRequestStream {
    inner: std::sync::Arc<fidl::ServeInner>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for IcdLoaderDeviceRequestStream {
    type Protocol = IcdLoaderDeviceMarker;
    type ControlHandle = IcdLoaderDeviceControlHandle;

    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 {
        IcdLoaderDeviceControlHandle { inner: self.inner.clone() }
    }

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

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

impl futures::Stream for IcdLoaderDeviceRequestStream {
    type Item = Result<IcdLoaderDeviceRequest, 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.poll_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled IcdLoaderDeviceRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf(|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))))
                }
            }

            // A message has been received from the channel
            let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
            if !header.is_compatible() {
                return std::task::Poll::Ready(Some(Err(fidl::Error::IncompatibleMagicNumber(
                    header.magic_number(),
                ))));
            }

            std::task::Poll::Ready(Some(match header.ordinal() {
                0x7673e76395008257 => {
                    let mut req: () = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/IcdLoaderDeviceGetIcdListRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = IcdLoaderDeviceControlHandle { inner: this.inner.clone() };

                    Ok(IcdLoaderDeviceRequest::GetIcdList {
                        responder: IcdLoaderDeviceGetIcdListResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id(),
                            ordinal: header.ordinal(),
                        },
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal(),
                    protocol_name:
                        <IcdLoaderDeviceMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
        })
    }
}
/// Methods implemented by an MSD and exposed for use of an ICD loader.
#[derive(Debug)]
pub enum IcdLoaderDeviceRequest {
    /// Returns a list of ICDs that can be used with this Magma device. The list is sorted in
    /// descending order of preference.
    GetIcdList { responder: IcdLoaderDeviceGetIcdListResponder },
}

impl IcdLoaderDeviceRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_icd_list(self) -> Option<(IcdLoaderDeviceGetIcdListResponder)> {
        if let IcdLoaderDeviceRequest::GetIcdList { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

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

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

impl fidl::endpoints::ControlHandle for IcdLoaderDeviceControlHandle {
    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<'a>(&'a self) -> fidl::OnSignals<'a> {
        self.inner.channel().on_closed()
    }
}

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

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

    fn control_handle(&self) -> &IcdLoaderDeviceControlHandle {
        &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 IcdLoaderDeviceGetIcdListResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut icd_list: &mut dyn ExactSizeIterator<Item = IcdInfo>,
    ) -> Result<(), fidl::Error> {
        let r = self.send_raw(icd_list);
        if r.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        r
    }

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

    fn send_raw(
        &self,
        mut icd_list: &mut dyn ExactSizeIterator<Item = IcdInfo>,
    ) -> Result<(), fidl::Error> {
        let mut response = (icd_list);

        let mut msg = fidl::encoding::TransactionMessage {
            header: fidl::encoding::TransactionHeader::new(
                self.tx_id,
                self.ordinal,
                fidl::encoding::DynamicFlags::empty(),
            ),
            body: &mut response,
        };

        fidl::encoding::with_tls_encode_buf(|bytes, handles| {
            fidl::duration_begin!("fidl", "encode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/IcdLoaderDeviceGetIcdListResponse");
            fidl::encoding::Encoder::encode(bytes, handles, &mut msg)?;
            fidl::trace_blob!("fidl:blob", "encode", bytes.as_slice());
            fidl::duration_end!("fidl", "encode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);

            self.control_handle.inner.send_raw_msg(&*bytes, &mut *handles)
        })
    }
}

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

impl fidl::endpoints::ProtocolMarker for NotificationMarker {
    type Proxy = NotificationProxy;
    type RequestStream = NotificationRequestStream;
    const DEBUG_NAME: &'static str = "(anonymous) Notification";
}

pub trait NotificationProxyInterface: Send + Sync {}

#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct NotificationSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl NotificationSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <NotificationMarker 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::Time) -> Result<NotificationEvent, fidl::Error> {
        NotificationEvent::decode(self.client.wait_for_event(deadline)?)
    }
}

#[derive(Debug, Clone)]
pub struct NotificationProxy {
    client: fidl::client::Client,
}

impl fidl::endpoints::Proxy for NotificationProxy {
    type Protocol = NotificationMarker;

    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 NotificationProxy {
    /// Create a new Proxy for Notification
    pub fn new(channel: fidl::AsyncChannel) -> Self {
        let protocol_name = <NotificationMarker 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 Notification protocol
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> NotificationEventStream {
        NotificationEventStream { event_receiver: self.client.take_event_receiver() }
    }
}

impl NotificationProxyInterface for NotificationProxy {}

pub struct NotificationEventStream {
    event_receiver: fidl::client::EventReceiver,
}

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

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

impl futures::Stream for NotificationEventStream {
    type Item = Result<NotificationEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let buf = match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => buf,
            None => return std::task::Poll::Ready(None),
        };

        std::task::Poll::Ready(Some(NotificationEvent::decode(buf)))
    }
}

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

impl NotificationEvent {
    /// Decodes a message buffer as a [`NotificationEvent`]. Transaction
    /// ID in the message must be zero; this method does not check TXID.
    fn decode(mut buf: fidl::MessageBufEtc) -> Result<NotificationEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

        match tx_header.ordinal() {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal(),
                protocol_name: <NotificationMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for Notification
pub struct NotificationRequestStream {
    inner: std::sync::Arc<fidl::ServeInner>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for NotificationRequestStream {
    type Protocol = NotificationMarker;
    type ControlHandle = NotificationControlHandle;

    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 {
        NotificationControlHandle { inner: self.inner.clone() }
    }

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

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

impl futures::Stream for NotificationRequestStream {
    type Item = Result<NotificationRequest, 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.poll_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled NotificationRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf(|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))))
                }
            }

            // A message has been received from the channel
            let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
            if !header.is_compatible() {
                return std::task::Poll::Ready(Some(Err(fidl::Error::IncompatibleMagicNumber(
                    header.magic_number(),
                ))));
            }

            std::task::Poll::Ready(Some(match header.ordinal() {
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal(),
                    protocol_name:
                        <NotificationMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
        })
    }
}
/// This protocol is empty as the message contents are vendor specific.
#[derive(Debug)]
pub enum NotificationRequest {}

impl NotificationRequest {
    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {}
    }
}

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

impl fidl::endpoints::ControlHandle for NotificationControlHandle {
    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<'a>(&'a self) -> fidl::OnSignals<'a> {
        self.inner.channel().on_closed()
    }
}

impl NotificationControlHandle {}

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

impl fidl::endpoints::ProtocolMarker for PerformanceCounterAccessMarker {
    type Proxy = PerformanceCounterAccessProxy;
    type RequestStream = PerformanceCounterAccessRequestStream;
    const DEBUG_NAME: &'static str = "(anonymous) PerformanceCounterAccess";
}

pub trait PerformanceCounterAccessProxyInterface: Send + Sync {
    type GetPerformanceCountTokenResponseFut: std::future::Future<Output = Result<(fidl::Event), fidl::Error>>
        + Send;
    fn r#get_performance_count_token(&self) -> Self::GetPerformanceCountTokenResponseFut;
}

#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct PerformanceCounterAccessSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl PerformanceCounterAccessSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <PerformanceCounterAccessMarker 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::Time,
    ) -> Result<PerformanceCounterAccessEvent, fidl::Error> {
        PerformanceCounterAccessEvent::decode(self.client.wait_for_event(deadline)?)
    }
    /// This access token is not used as an event, but is instead passed to
    /// Primary.EnablePerformanceCounterAccess.
    pub fn r#get_performance_count_token(
        &self,
        ___deadline: zx::Time,
    ) -> Result<(fidl::Event), fidl::Error> {
        let _value: (HandleWrapperObjectTypeEVENTRights2147483648<fidl::Event>,) =
            self.client.send_query::<_, _, false, false>(
                &mut (),
                0x48410470c5f00f92,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_value.0.into_inner())
    }
}

#[derive(Debug, Clone)]
pub struct PerformanceCounterAccessProxy {
    client: fidl::client::Client,
}

impl fidl::endpoints::Proxy for PerformanceCounterAccessProxy {
    type Protocol = PerformanceCounterAccessMarker;

    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 PerformanceCounterAccessProxy {
    /// Create a new Proxy for PerformanceCounterAccess
    pub fn new(channel: fidl::AsyncChannel) -> Self {
        let protocol_name =
            <PerformanceCounterAccessMarker 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 PerformanceCounterAccess protocol
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> PerformanceCounterAccessEventStream {
        PerformanceCounterAccessEventStream { event_receiver: self.client.take_event_receiver() }
    }
    /// This access token is not used as an event, but is instead passed to
    /// Primary.EnablePerformanceCounterAccess.
    pub fn r#get_performance_count_token(&self) -> fidl::client::QueryResponseFut<(fidl::Event)> {
        PerformanceCounterAccessProxyInterface::r#get_performance_count_token(self)
    }
}

impl PerformanceCounterAccessProxyInterface for PerformanceCounterAccessProxy {
    type GetPerformanceCountTokenResponseFut = fidl::client::QueryResponseFut<(fidl::Event)>;
    fn r#get_performance_count_token(&self) -> Self::GetPerformanceCountTokenResponseFut {
        fn transform(
            result: Result<
                (HandleWrapperObjectTypeEVENTRights2147483648<fidl::Event>,),
                fidl::Error,
            >,
        ) -> Result<(fidl::Event), fidl::Error> {
            result.map(|_value| _value.0.into_inner())
        }
        let send_result = self.client.call_send_raw_query::<_, false>(
            &mut (),
            0x48410470c5f00f92,
            fidl::encoding::DynamicFlags::empty(),
        );
        QueryResponseFut(match send_result {
            Ok(res_fut) => future::maybe_done(
                res_fut.and_then(|buf| decode_transaction_body_fut::<_, _, false>(buf, transform)),
            ),
            Err(e) => MaybeDone::Done(Err(e)),
        })
    }
}

pub struct PerformanceCounterAccessEventStream {
    event_receiver: fidl::client::EventReceiver,
}

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

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

impl futures::Stream for PerformanceCounterAccessEventStream {
    type Item = Result<PerformanceCounterAccessEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let buf = match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => buf,
            None => return std::task::Poll::Ready(None),
        };

        std::task::Poll::Ready(Some(PerformanceCounterAccessEvent::decode(buf)))
    }
}

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

impl PerformanceCounterAccessEvent {
    /// Decodes a message buffer as a [`PerformanceCounterAccessEvent`]. Transaction
    /// ID in the message must be zero; this method does not check TXID.
    fn decode(mut buf: fidl::MessageBufEtc) -> Result<PerformanceCounterAccessEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

        match tx_header.ordinal() {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal(),
                protocol_name:
                    <PerformanceCounterAccessMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for PerformanceCounterAccess
pub struct PerformanceCounterAccessRequestStream {
    inner: std::sync::Arc<fidl::ServeInner>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for PerformanceCounterAccessRequestStream {
    type Protocol = PerformanceCounterAccessMarker;
    type ControlHandle = PerformanceCounterAccessControlHandle;

    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 {
        PerformanceCounterAccessControlHandle { inner: self.inner.clone() }
    }

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

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

impl futures::Stream for PerformanceCounterAccessRequestStream {
    type Item = Result<PerformanceCounterAccessRequest, 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.poll_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled PerformanceCounterAccessRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf(|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))))
                }
            }

            // A message has been received from the channel
            let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
            if !header.is_compatible() {
                return std::task::Poll::Ready(Some(Err(fidl::Error::IncompatibleMagicNumber(
                    header.magic_number(),
                ))));
            }

            std::task::Poll::Ready(Some(match header.ordinal() {
                0x48410470c5f00f92 => {
                    let mut req: () = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/PerformanceCounterAccessGetPerformanceCountTokenRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW) {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = PerformanceCounterAccessControlHandle {
                        inner: this.inner.clone(),
                    };

                    Ok(PerformanceCounterAccessRequest::GetPerformanceCountToken {responder:PerformanceCounterAccessGetPerformanceCountTokenResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id(),
                                ordinal: header.ordinal(),
                            },})
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal(),
                    protocol_name: <PerformanceCounterAccessMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
        })
    }
}
/// This protocol is implemented by ZX_PROTOCOL_GPU_PERFORMANCE_COUNTERS devices.
#[derive(Debug)]
pub enum PerformanceCounterAccessRequest {
    /// This access token is not used as an event, but is instead passed to
    /// Primary.EnablePerformanceCounterAccess.
    GetPerformanceCountToken {
        responder: PerformanceCounterAccessGetPerformanceCountTokenResponder,
    },
}

impl PerformanceCounterAccessRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_performance_count_token(
        self,
    ) -> Option<(PerformanceCounterAccessGetPerformanceCountTokenResponder)> {
        if let PerformanceCounterAccessRequest::GetPerformanceCountToken { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

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

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

impl fidl::endpoints::ControlHandle for PerformanceCounterAccessControlHandle {
    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<'a>(&'a self) -> fidl::OnSignals<'a> {
        self.inner.channel().on_closed()
    }
}

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

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

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

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

    fn send_raw(&self, mut access_token: fidl::Event) -> Result<(), fidl::Error> {
        let mut response =
            (HandleWrapperObjectTypeEVENTRights2147483648::<fidl::Event>(access_token));

        let mut msg = fidl::encoding::TransactionMessage {
            header: fidl::encoding::TransactionHeader::new(
                self.tx_id,
                self.ordinal,
                fidl::encoding::DynamicFlags::empty(),
            ),
            body: &mut response,
        };

        fidl::encoding::with_tls_encode_buf(|bytes, handles| {
            fidl::duration_begin!("fidl", "encode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/PerformanceCounterAccessGetPerformanceCountTokenResponse");
            fidl::encoding::Encoder::encode(bytes, handles, &mut msg)?;
            fidl::trace_blob!("fidl:blob", "encode", bytes.as_slice());
            fidl::duration_end!("fidl", "encode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);

            self.control_handle.inner.send_raw_msg(&*bytes, &mut *handles)
        })
    }
}

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

impl fidl::endpoints::ProtocolMarker for PerformanceCounterEventsMarker {
    type Proxy = PerformanceCounterEventsProxy;
    type RequestStream = PerformanceCounterEventsRequestStream;
    const DEBUG_NAME: &'static str = "(anonymous) PerformanceCounterEvents";
}

pub trait PerformanceCounterEventsProxyInterface: Send + Sync {}

#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct PerformanceCounterEventsSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl PerformanceCounterEventsSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <PerformanceCounterEventsMarker 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::Time,
    ) -> Result<PerformanceCounterEventsEvent, fidl::Error> {
        PerformanceCounterEventsEvent::decode(self.client.wait_for_event(deadline)?)
    }
}

#[derive(Debug, Clone)]
pub struct PerformanceCounterEventsProxy {
    client: fidl::client::Client,
}

impl fidl::endpoints::Proxy for PerformanceCounterEventsProxy {
    type Protocol = PerformanceCounterEventsMarker;

    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 PerformanceCounterEventsProxy {
    /// Create a new Proxy for PerformanceCounterEvents
    pub fn new(channel: fidl::AsyncChannel) -> Self {
        let protocol_name =
            <PerformanceCounterEventsMarker 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 PerformanceCounterEvents protocol
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> PerformanceCounterEventsEventStream {
        PerformanceCounterEventsEventStream { event_receiver: self.client.take_event_receiver() }
    }
}

impl PerformanceCounterEventsProxyInterface for PerformanceCounterEventsProxy {}

pub struct PerformanceCounterEventsEventStream {
    event_receiver: fidl::client::EventReceiver,
}

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

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

impl futures::Stream for PerformanceCounterEventsEventStream {
    type Item = Result<PerformanceCounterEventsEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let buf = match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => buf,
            None => return std::task::Poll::Ready(None),
        };

        std::task::Poll::Ready(Some(PerformanceCounterEventsEvent::decode(buf)))
    }
}

#[derive(Debug)]
pub enum PerformanceCounterEventsEvent {
    OnPerformanceCounterReadCompleted {
        payload: PerformanceCounterEventsOnPerformanceCounterReadCompletedRequest,
    },
}

impl PerformanceCounterEventsEvent {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_performance_counter_read_completed(
        self,
    ) -> Option<(PerformanceCounterEventsOnPerformanceCounterReadCompletedRequest)> {
        if let PerformanceCounterEventsEvent::OnPerformanceCounterReadCompleted { payload } = self {
            Some((payload))
        } else {
            None
        }
    }

    /// Decodes a message buffer as a [`PerformanceCounterEventsEvent`]. Transaction
    /// ID in the message must be zero; this method does not check TXID.
    fn decode(mut buf: fidl::MessageBufEtc) -> Result<PerformanceCounterEventsEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

        match tx_header.ordinal() {
            0x3f134926720d44d7 => {
                let mut out_tuple: (
                    PerformanceCounterEventsOnPerformanceCounterReadCompletedRequest,
                ) = fidl::encoding::Decodable::new_empty();
                fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/PerformanceCounterEventsOnPerformanceCounterReadCompletedEvent");
                fidl::trace_blob!("fidl:blob", "decode", bytes);
                fidl::encoding::maybe_overflowing_decode(
                    &tx_header,
                    _body_bytes,
                    _handles,
                    &mut out_tuple,
                )?;
                fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => _handles.len() as u32);
                Ok((PerformanceCounterEventsEvent::OnPerformanceCounterReadCompleted {
                    payload: out_tuple.0,
                }))
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal(),
                protocol_name:
                    <PerformanceCounterEventsMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for PerformanceCounterEvents
pub struct PerformanceCounterEventsRequestStream {
    inner: std::sync::Arc<fidl::ServeInner>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for PerformanceCounterEventsRequestStream {
    type Protocol = PerformanceCounterEventsMarker;
    type ControlHandle = PerformanceCounterEventsControlHandle;

    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 {
        PerformanceCounterEventsControlHandle { inner: self.inner.clone() }
    }

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

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

impl futures::Stream for PerformanceCounterEventsRequestStream {
    type Item = Result<PerformanceCounterEventsRequest, 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.poll_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled PerformanceCounterEventsRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf(|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))))
                }
            }

            // A message has been received from the channel
            let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
            if !header.is_compatible() {
                return std::task::Poll::Ready(Some(Err(fidl::Error::IncompatibleMagicNumber(
                    header.magic_number(),
                ))));
            }

            std::task::Poll::Ready(Some(match header.ordinal() {
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal(),
                    protocol_name: <PerformanceCounterEventsMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
        })
    }
}
#[derive(Debug)]
pub enum PerformanceCounterEventsRequest {}

impl PerformanceCounterEventsRequest {
    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {}
    }
}

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

impl fidl::endpoints::ControlHandle for PerformanceCounterEventsControlHandle {
    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<'a>(&'a self) -> fidl::OnSignals<'a> {
        self.inner.channel().on_closed()
    }
}

impl PerformanceCounterEventsControlHandle {
    pub fn send_on_performance_counter_read_completed(
        &self,
        mut payload: PerformanceCounterEventsOnPerformanceCounterReadCompletedRequest,
    ) -> Result<(), fidl::Error> {
        let mut response = (payload);
        self.inner.send::<_, false>(
            &mut response,
            0,
            0x3f134926720d44d7,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for PrimaryMarker {
    type Proxy = PrimaryProxy;
    type RequestStream = PrimaryRequestStream;
    const DEBUG_NAME: &'static str = "(anonymous) Primary";
}

pub trait PrimaryProxyInterface: Send + Sync {
    fn r#import_object2(
        &self,
        object: fidl::Handle,
        object_type: ObjectType,
        object_id: u64,
    ) -> Result<(), fidl::Error>;
    fn r#release_object(&self, object_id: u64, object_type: ObjectType) -> Result<(), fidl::Error>;
    fn r#create_context(&self, context_id: u32) -> Result<(), fidl::Error>;
    fn r#destroy_context(&self, context_id: u32) -> Result<(), fidl::Error>;
    fn r#execute_command(
        &self,
        context_id: u32,
        resources: &mut dyn ExactSizeIterator<Item = &mut BufferRange>,
        command_buffers: &mut dyn ExactSizeIterator<Item = &mut CommandBuffer>,
        wait_semaphores: &[u64],
        signal_semaphores: &[u64],
        flags: CommandBufferFlags,
    ) -> Result<(), fidl::Error>;
    fn r#execute_immediate_commands(
        &self,
        context_id: u32,
        command_data: &[u8],
        semaphores: &[u64],
    ) -> Result<(), fidl::Error>;
    type FlushResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#flush(&self) -> Self::FlushResponseFut;
    fn r#map_buffer(&self, payload: PrimaryMapBufferRequest) -> Result<(), fidl::Error>;
    fn r#unmap_buffer(&self, payload: PrimaryUnmapBufferRequest) -> Result<(), fidl::Error>;
    fn r#buffer_range_op2(&self, op: BufferOp, range: &mut BufferRange) -> Result<(), fidl::Error>;
    fn r#enable_flow_control(&self) -> Result<(), fidl::Error>;
    fn r#enable_performance_counter_access(
        &self,
        access_token: fidl::Event,
    ) -> Result<(), fidl::Error>;
    type IsPerformanceCounterAccessAllowedResponseFut: std::future::Future<Output = Result<(bool), fidl::Error>>
        + Send;
    fn r#is_performance_counter_access_allowed(
        &self,
    ) -> Self::IsPerformanceCounterAccessAllowedResponseFut;
    fn r#enable_performance_counters(&self, counters: &[u64]) -> Result<(), fidl::Error>;
    fn r#create_performance_counter_buffer_pool(
        &self,
        pool_id: u64,
        event_channel: fidl::endpoints::ServerEnd<PerformanceCounterEventsMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#release_performance_counter_buffer_pool(&self, pool_id: u64) -> Result<(), fidl::Error>;
    fn r#add_performance_counter_buffer_offsets_to_pool(
        &self,
        pool_id: u64,
        offsets: &mut dyn ExactSizeIterator<Item = &mut BufferRange>,
    ) -> Result<(), fidl::Error>;
    fn r#remove_performance_counter_buffer_from_pool(
        &self,
        pool_id: u64,
        buffer_id: u64,
    ) -> Result<(), fidl::Error>;
    fn r#dump_performance_counters(&self, pool_id: u64, trigger_id: u32)
        -> Result<(), fidl::Error>;
    fn r#clear_performance_counters(&self, counters: &[u64]) -> Result<(), fidl::Error>;
}

#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct PrimarySynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl PrimarySynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <PrimaryMarker 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::Time) -> Result<PrimaryEvent, fidl::Error> {
        PrimaryEvent::decode(self.client.wait_for_event(deadline)?)
    }
    /// Imports an object for use in the system driver.
    pub fn r#import_object2(
        &self,
        mut object: fidl::Handle,
        mut object_type: ObjectType,
        mut object_id: u64,
    ) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (
                HandleWrapperObjectTypeNONERights2147483648::<fidl::Handle>(object),
                object_type,
                object_id,
            ),
            0x774ef4bc434f6b40,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    /// Destroys the object with `object_id` within this connection.
    pub fn r#release_object(
        &self,
        mut object_id: u64,
        mut object_type: ObjectType,
    ) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (object_id, object_type),
            0x4a65d5885da5e88f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    /// Creates context `context_id` for use in command execution.  A context may be associated
    /// with hardware state.
    pub fn r#create_context(&self, mut context_id: u32) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (context_id,),
            0x5a9a91c8b88b5da4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    /// Destroys context `context_id`.
    pub fn r#destroy_context(&self, mut context_id: u32) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (context_id,),
            0x26b626e6be162ef0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    /// Submits command buffers for execution on the hardware, with associated `resources`.
    /// `resources` must refer to buffers that have been imported.
    /// `wait_semaphores` and `signal_semaphores` must refer to events that have been imported.
    /// `wait_semaphores` must all be signaled before execution begins, then are reset.
    /// `signal_semaphores` will be signaled after the command buffer is completed.
    pub fn r#execute_command(
        &self,
        mut context_id: u32,
        mut resources: &mut dyn ExactSizeIterator<Item = &mut BufferRange>,
        mut command_buffers: &mut dyn ExactSizeIterator<Item = &mut CommandBuffer>,
        mut wait_semaphores: &[u64],
        mut signal_semaphores: &[u64],
        mut flags: CommandBufferFlags,
    ) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (
                context_id,
                resources,
                command_buffers,
                wait_semaphores,
                signal_semaphores,
                flags,
            ),
            0xf2799643aadb0db,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    /// Submits a series of commands for execution on the hardware without using a command buffer.
    /// `semaphores` must refer to events that have been imported, and will be signaled after
    /// the commands are completed.
    pub fn r#execute_immediate_commands(
        &self,
        mut context_id: u32,
        mut command_data: &[u8],
        mut semaphores: &[u64],
    ) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (context_id, command_data, semaphores),
            0x3d7e0dcdbfd4b61f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    /// Incurs a round-trip to the system driver, used to ensure all previous messages have been
    /// observed, but not necessarily completed.
    pub fn r#flush(&self, ___deadline: zx::Time) -> Result<(), fidl::Error> {
        let _value: () = self.client.send_query::<_, _, false, false>(
            &mut (),
            0x54ccb5572d886039,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(())
    }
    /// Maps a page range onto the hardware in the connection's address space at address `hw_va`.
    /// `flags` is a set of flags from MapFlags that specify how the hardware can access the buffer.
    pub fn r#map_buffer(&self, mut payload: PrimaryMapBufferRequest) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (payload,),
            0x56baa5d2092c8e33,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    /// Releases the mapping at address `hw_va` from the hardware for the given `buffer_id`.
    /// Buffers will also be implicitly unmapped when released.
    pub fn r#unmap_buffer(
        &self,
        mut payload: PrimaryUnmapBufferRequest,
    ) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (payload,),
            0x305188ebd8bcd95c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    /// Perform an operation on a range of the buffer.
    pub fn r#buffer_range_op2(
        &self,
        mut op: BufferOp,
        mut range: &mut BufferRange,
    ) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (op, range),
            0x4175c8dfef355396,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    /// Enables the events OnNotifyMessagesConsumed and OnNotifyMemoryImported.
    pub fn r#enable_flow_control(&self) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (),
            0x8b5e68f3ee0b22e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    /// Tries to enable performance counter FIDL messages. To be successful, |access_token| must
    /// have been returned by PerformanceCounterAccess.GetPerformanceCountToken() from the matching
    /// device.
    pub fn r#enable_performance_counter_access(
        &self,
        mut access_token: fidl::Event,
    ) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (HandleWrapperObjectTypeEVENTRights2147483648::<fidl::Event>(access_token),),
            0x51b369ac16588831,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    /// Returns true if any EnablePerformanceCounterAccess message has succeeded.
    pub fn r#is_performance_counter_access_allowed(
        &self,
        ___deadline: zx::Time,
    ) -> Result<(bool), fidl::Error> {
        let _value: (bool,) = self.client.send_query::<_, _, false, false>(
            &mut (),
            0x1933b70c06cc5702,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_value.0)
    }
    /// Enables a set of performance counters.  Disables enabled performance counters that are not
    /// in the new set. Performance counters will also be automatically disabled on connection
    /// close. Performance counter access must have been enabled using
    /// EnablePerformanceCounterAccess before calling this method.
    pub fn r#enable_performance_counters(&self, mut counters: &[u64]) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (counters,),
            0x52c4db74b601aaa7,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    /// Creates a pool of buffers that performance counters can be dumped into. Performance counter
    /// access must have been enabled using EnablePerformanceCounterAccess before calling this
    /// method.
    pub fn r#create_performance_counter_buffer_pool(
        &self,
        mut pool_id: u64,
        mut event_channel: fidl::endpoints::ServerEnd<PerformanceCounterEventsMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (
                pool_id,
                HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT::<
                    fidl::endpoints::ServerEnd<PerformanceCounterEventsMarker>,
                >(event_channel),
            ),
            0x48ccf6519bbbc638,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    /// Releases a pool of performance counter buffers. Performance counter access must have been
    /// enabled using EnablePerformanceCounterAccess before calling this method.
    pub fn r#release_performance_counter_buffer_pool(
        &self,
        mut pool_id: u64,
    ) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (pool_id,),
            0x18374c4b3ef0b4da,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    /// Adds a set of offsets into buffers to the pool. |offsets[n].buffer_id| is the id of a
    /// buffer that was previously imported using ImportBuffer(). The same buffer may be added to
    /// multiple pools. The pool will hold on to a reference to the buffer even after ReleaseBuffer
    /// is called.  When dumped into this entry, counters will be written starting at
    /// |offsets[n].buffer_offset| bytes into the buffer, and up to |offsets[n].buffer_offset| +
    /// |offsets[n].buffer_size|. |offsets[n].buffer_size| must be large enough to fit all enabled
    /// counters. Performance counter access must have been enabled using
    /// EnablePerformanceCounterAccess before calling this method.
    pub fn r#add_performance_counter_buffer_offsets_to_pool(
        &self,
        mut pool_id: u64,
        mut offsets: &mut dyn ExactSizeIterator<Item = &mut BufferRange>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (pool_id, offsets),
            0x1f7889571111386b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    /// Removes every offset of a buffer from the pool. Once this method is finished being handled
    /// on the server, no more dumps will be processed into this buffer. In-flight dumps into this
    /// buffer may be lost.  Performance counter access must have been enabled using
    /// EnablePerformanceCounterAccess before calling this method.
    pub fn r#remove_performance_counter_buffer_from_pool(
        &self,
        mut pool_id: u64,
        mut buffer_id: u64,
    ) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (pool_id, buffer_id),
            0xbf1275f5a36258e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    /// Triggers dumping of the performance counters into a buffer pool. May fail silently if there
    /// are no buffers in the pool. |trigger_id| is an arbitrary ID assigned by the client that can
    /// be returned in OnPerformanceCounterReadCompleted. Performance counter access must have been
    /// enabled using EnablePerformanceCounterAccess before calling this method.
    pub fn r#dump_performance_counters(
        &self,
        mut pool_id: u64,
        mut trigger_id: u32,
    ) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (pool_id, trigger_id),
            0x250b29340be28807,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    /// Sets the values of all listed performance counters to 0. May not be supported by some
    /// hardware. Performance counter access must have been enabled using
    /// EnablePerformanceCounterAccess before calling this method.
    pub fn r#clear_performance_counters(&self, mut counters: &[u64]) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (counters,),
            0x236831822eff741a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[derive(Debug, Clone)]
pub struct PrimaryProxy {
    client: fidl::client::Client,
}

impl fidl::endpoints::Proxy for PrimaryProxy {
    type Protocol = PrimaryMarker;

    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 PrimaryProxy {
    /// Create a new Proxy for Primary
    pub fn new(channel: fidl::AsyncChannel) -> Self {
        let protocol_name = <PrimaryMarker 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 Primary protocol
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> PrimaryEventStream {
        PrimaryEventStream { event_receiver: self.client.take_event_receiver() }
    }
    /// Imports an object for use in the system driver.
    pub fn r#import_object2(
        &self,
        mut object: fidl::Handle,
        mut object_type: ObjectType,
        mut object_id: u64,
    ) -> Result<(), fidl::Error> {
        PrimaryProxyInterface::r#import_object2(self, object, object_type, object_id)
    }
    /// Destroys the object with `object_id` within this connection.
    pub fn r#release_object(
        &self,
        mut object_id: u64,
        mut object_type: ObjectType,
    ) -> Result<(), fidl::Error> {
        PrimaryProxyInterface::r#release_object(self, object_id, object_type)
    }
    /// Creates context `context_id` for use in command execution.  A context may be associated
    /// with hardware state.
    pub fn r#create_context(&self, mut context_id: u32) -> Result<(), fidl::Error> {
        PrimaryProxyInterface::r#create_context(self, context_id)
    }
    /// Destroys context `context_id`.
    pub fn r#destroy_context(&self, mut context_id: u32) -> Result<(), fidl::Error> {
        PrimaryProxyInterface::r#destroy_context(self, context_id)
    }
    /// Submits command buffers for execution on the hardware, with associated `resources`.
    /// `resources` must refer to buffers that have been imported.
    /// `wait_semaphores` and `signal_semaphores` must refer to events that have been imported.
    /// `wait_semaphores` must all be signaled before execution begins, then are reset.
    /// `signal_semaphores` will be signaled after the command buffer is completed.
    pub fn r#execute_command(
        &self,
        mut context_id: u32,
        mut resources: &mut dyn ExactSizeIterator<Item = &mut BufferRange>,
        mut command_buffers: &mut dyn ExactSizeIterator<Item = &mut CommandBuffer>,
        mut wait_semaphores: &[u64],
        mut signal_semaphores: &[u64],
        mut flags: CommandBufferFlags,
    ) -> Result<(), fidl::Error> {
        PrimaryProxyInterface::r#execute_command(
            self,
            context_id,
            resources,
            command_buffers,
            wait_semaphores,
            signal_semaphores,
            flags,
        )
    }
    /// Submits a series of commands for execution on the hardware without using a command buffer.
    /// `semaphores` must refer to events that have been imported, and will be signaled after
    /// the commands are completed.
    pub fn r#execute_immediate_commands(
        &self,
        mut context_id: u32,
        mut command_data: &[u8],
        mut semaphores: &[u64],
    ) -> Result<(), fidl::Error> {
        PrimaryProxyInterface::r#execute_immediate_commands(
            self,
            context_id,
            command_data,
            semaphores,
        )
    }
    /// Incurs a round-trip to the system driver, used to ensure all previous messages have been
    /// observed, but not necessarily completed.
    pub fn r#flush(&self) -> fidl::client::QueryResponseFut<()> {
        PrimaryProxyInterface::r#flush(self)
    }
    /// Maps a page range onto the hardware in the connection's address space at address `hw_va`.
    /// `flags` is a set of flags from MapFlags that specify how the hardware can access the buffer.
    pub fn r#map_buffer(&self, mut payload: PrimaryMapBufferRequest) -> Result<(), fidl::Error> {
        PrimaryProxyInterface::r#map_buffer(self, payload)
    }
    /// Releases the mapping at address `hw_va` from the hardware for the given `buffer_id`.
    /// Buffers will also be implicitly unmapped when released.
    pub fn r#unmap_buffer(
        &self,
        mut payload: PrimaryUnmapBufferRequest,
    ) -> Result<(), fidl::Error> {
        PrimaryProxyInterface::r#unmap_buffer(self, payload)
    }
    /// Perform an operation on a range of the buffer.
    pub fn r#buffer_range_op2(
        &self,
        mut op: BufferOp,
        mut range: &mut BufferRange,
    ) -> Result<(), fidl::Error> {
        PrimaryProxyInterface::r#buffer_range_op2(self, op, range)
    }
    /// Enables the events OnNotifyMessagesConsumed and OnNotifyMemoryImported.
    pub fn r#enable_flow_control(&self) -> Result<(), fidl::Error> {
        PrimaryProxyInterface::r#enable_flow_control(self)
    }
    /// Tries to enable performance counter FIDL messages. To be successful, |access_token| must
    /// have been returned by PerformanceCounterAccess.GetPerformanceCountToken() from the matching
    /// device.
    pub fn r#enable_performance_counter_access(
        &self,
        mut access_token: fidl::Event,
    ) -> Result<(), fidl::Error> {
        PrimaryProxyInterface::r#enable_performance_counter_access(self, access_token)
    }
    /// Returns true if any EnablePerformanceCounterAccess message has succeeded.
    pub fn r#is_performance_counter_access_allowed(
        &self,
    ) -> fidl::client::QueryResponseFut<(bool)> {
        PrimaryProxyInterface::r#is_performance_counter_access_allowed(self)
    }
    /// Enables a set of performance counters.  Disables enabled performance counters that are not
    /// in the new set. Performance counters will also be automatically disabled on connection
    /// close. Performance counter access must have been enabled using
    /// EnablePerformanceCounterAccess before calling this method.
    pub fn r#enable_performance_counters(&self, mut counters: &[u64]) -> Result<(), fidl::Error> {
        PrimaryProxyInterface::r#enable_performance_counters(self, counters)
    }
    /// Creates a pool of buffers that performance counters can be dumped into. Performance counter
    /// access must have been enabled using EnablePerformanceCounterAccess before calling this
    /// method.
    pub fn r#create_performance_counter_buffer_pool(
        &self,
        mut pool_id: u64,
        mut event_channel: fidl::endpoints::ServerEnd<PerformanceCounterEventsMarker>,
    ) -> Result<(), fidl::Error> {
        PrimaryProxyInterface::r#create_performance_counter_buffer_pool(
            self,
            pool_id,
            event_channel,
        )
    }
    /// Releases a pool of performance counter buffers. Performance counter access must have been
    /// enabled using EnablePerformanceCounterAccess before calling this method.
    pub fn r#release_performance_counter_buffer_pool(
        &self,
        mut pool_id: u64,
    ) -> Result<(), fidl::Error> {
        PrimaryProxyInterface::r#release_performance_counter_buffer_pool(self, pool_id)
    }
    /// Adds a set of offsets into buffers to the pool. |offsets[n].buffer_id| is the id of a
    /// buffer that was previously imported using ImportBuffer(). The same buffer may be added to
    /// multiple pools. The pool will hold on to a reference to the buffer even after ReleaseBuffer
    /// is called.  When dumped into this entry, counters will be written starting at
    /// |offsets[n].buffer_offset| bytes into the buffer, and up to |offsets[n].buffer_offset| +
    /// |offsets[n].buffer_size|. |offsets[n].buffer_size| must be large enough to fit all enabled
    /// counters. Performance counter access must have been enabled using
    /// EnablePerformanceCounterAccess before calling this method.
    pub fn r#add_performance_counter_buffer_offsets_to_pool(
        &self,
        mut pool_id: u64,
        mut offsets: &mut dyn ExactSizeIterator<Item = &mut BufferRange>,
    ) -> Result<(), fidl::Error> {
        PrimaryProxyInterface::r#add_performance_counter_buffer_offsets_to_pool(
            self, pool_id, offsets,
        )
    }
    /// Removes every offset of a buffer from the pool. Once this method is finished being handled
    /// on the server, no more dumps will be processed into this buffer. In-flight dumps into this
    /// buffer may be lost.  Performance counter access must have been enabled using
    /// EnablePerformanceCounterAccess before calling this method.
    pub fn r#remove_performance_counter_buffer_from_pool(
        &self,
        mut pool_id: u64,
        mut buffer_id: u64,
    ) -> Result<(), fidl::Error> {
        PrimaryProxyInterface::r#remove_performance_counter_buffer_from_pool(
            self, pool_id, buffer_id,
        )
    }
    /// Triggers dumping of the performance counters into a buffer pool. May fail silently if there
    /// are no buffers in the pool. |trigger_id| is an arbitrary ID assigned by the client that can
    /// be returned in OnPerformanceCounterReadCompleted. Performance counter access must have been
    /// enabled using EnablePerformanceCounterAccess before calling this method.
    pub fn r#dump_performance_counters(
        &self,
        mut pool_id: u64,
        mut trigger_id: u32,
    ) -> Result<(), fidl::Error> {
        PrimaryProxyInterface::r#dump_performance_counters(self, pool_id, trigger_id)
    }
    /// Sets the values of all listed performance counters to 0. May not be supported by some
    /// hardware. Performance counter access must have been enabled using
    /// EnablePerformanceCounterAccess before calling this method.
    pub fn r#clear_performance_counters(&self, mut counters: &[u64]) -> Result<(), fidl::Error> {
        PrimaryProxyInterface::r#clear_performance_counters(self, counters)
    }
}

impl PrimaryProxyInterface for PrimaryProxy {
    fn r#import_object2(
        &self,
        mut object: fidl::Handle,
        mut object_type: ObjectType,
        mut object_id: u64,
    ) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (
                HandleWrapperObjectTypeNONERights2147483648::<fidl::Handle>(object),
                object_type,
                object_id,
            ),
            0x774ef4bc434f6b40,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    fn r#release_object(
        &self,
        mut object_id: u64,
        mut object_type: ObjectType,
    ) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (object_id, object_type),
            0x4a65d5885da5e88f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    fn r#create_context(&self, mut context_id: u32) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (context_id),
            0x5a9a91c8b88b5da4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    fn r#destroy_context(&self, mut context_id: u32) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (context_id),
            0x26b626e6be162ef0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    fn r#execute_command(
        &self,
        mut context_id: u32,
        mut resources: &mut dyn ExactSizeIterator<Item = &mut BufferRange>,
        mut command_buffers: &mut dyn ExactSizeIterator<Item = &mut CommandBuffer>,
        mut wait_semaphores: &[u64],
        mut signal_semaphores: &[u64],
        mut flags: CommandBufferFlags,
    ) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (
                context_id,
                resources,
                command_buffers,
                wait_semaphores,
                signal_semaphores,
                flags,
            ),
            0xf2799643aadb0db,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    fn r#execute_immediate_commands(
        &self,
        mut context_id: u32,
        mut command_data: &[u8],
        mut semaphores: &[u64],
    ) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (context_id, command_data, semaphores),
            0x3d7e0dcdbfd4b61f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    type FlushResponseFut = fidl::client::QueryResponseFut<()>;
    fn r#flush(&self) -> Self::FlushResponseFut {
        fn transform(result: Result<(), fidl::Error>) -> Result<(), fidl::Error> {
            result.map(|_value| ())
        }
        let send_result = self.client.call_send_raw_query::<_, false>(
            &mut (),
            0x54ccb5572d886039,
            fidl::encoding::DynamicFlags::empty(),
        );
        QueryResponseFut(match send_result {
            Ok(res_fut) => future::maybe_done(
                res_fut.and_then(|buf| decode_transaction_body_fut::<_, _, false>(buf, transform)),
            ),
            Err(e) => MaybeDone::Done(Err(e)),
        })
    }
    fn r#map_buffer(&self, mut payload: PrimaryMapBufferRequest) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (payload),
            0x56baa5d2092c8e33,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    fn r#unmap_buffer(&self, mut payload: PrimaryUnmapBufferRequest) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (payload),
            0x305188ebd8bcd95c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    fn r#buffer_range_op2(
        &self,
        mut op: BufferOp,
        mut range: &mut BufferRange,
    ) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (op, range),
            0x4175c8dfef355396,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    fn r#enable_flow_control(&self) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (),
            0x8b5e68f3ee0b22e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    fn r#enable_performance_counter_access(
        &self,
        mut access_token: fidl::Event,
    ) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (HandleWrapperObjectTypeEVENTRights2147483648::<fidl::Event>(access_token)),
            0x51b369ac16588831,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    type IsPerformanceCounterAccessAllowedResponseFut = fidl::client::QueryResponseFut<(bool)>;
    fn r#is_performance_counter_access_allowed(
        &self,
    ) -> Self::IsPerformanceCounterAccessAllowedResponseFut {
        fn transform(result: Result<(bool,), fidl::Error>) -> Result<(bool), fidl::Error> {
            result.map(|_value| _value.0)
        }
        let send_result = self.client.call_send_raw_query::<_, false>(
            &mut (),
            0x1933b70c06cc5702,
            fidl::encoding::DynamicFlags::empty(),
        );
        QueryResponseFut(match send_result {
            Ok(res_fut) => future::maybe_done(
                res_fut.and_then(|buf| decode_transaction_body_fut::<_, _, false>(buf, transform)),
            ),
            Err(e) => MaybeDone::Done(Err(e)),
        })
    }
    fn r#enable_performance_counters(&self, mut counters: &[u64]) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (counters),
            0x52c4db74b601aaa7,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    fn r#create_performance_counter_buffer_pool(
        &self,
        mut pool_id: u64,
        mut event_channel: fidl::endpoints::ServerEnd<PerformanceCounterEventsMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (
                pool_id,
                HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT::<
                    fidl::endpoints::ServerEnd<PerformanceCounterEventsMarker>,
                >(event_channel),
            ),
            0x48ccf6519bbbc638,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    fn r#release_performance_counter_buffer_pool(
        &self,
        mut pool_id: u64,
    ) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (pool_id),
            0x18374c4b3ef0b4da,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    fn r#add_performance_counter_buffer_offsets_to_pool(
        &self,
        mut pool_id: u64,
        mut offsets: &mut dyn ExactSizeIterator<Item = &mut BufferRange>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (pool_id, offsets),
            0x1f7889571111386b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    fn r#remove_performance_counter_buffer_from_pool(
        &self,
        mut pool_id: u64,
        mut buffer_id: u64,
    ) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (pool_id, buffer_id),
            0xbf1275f5a36258e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    fn r#dump_performance_counters(
        &self,
        mut pool_id: u64,
        mut trigger_id: u32,
    ) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (pool_id, trigger_id),
            0x250b29340be28807,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    fn r#clear_performance_counters(&self, mut counters: &[u64]) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (counters),
            0x236831822eff741a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

pub struct PrimaryEventStream {
    event_receiver: fidl::client::EventReceiver,
}

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

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

impl futures::Stream for PrimaryEventStream {
    type Item = Result<PrimaryEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let buf = match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => buf,
            None => return std::task::Poll::Ready(None),
        };

        std::task::Poll::Ready(Some(PrimaryEvent::decode(buf)))
    }
}

#[derive(Debug)]
pub enum PrimaryEvent {
    OnNotifyMessagesConsumed { count: u64 },

    OnNotifyMemoryImported { bytes: u64 },
}

impl PrimaryEvent {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_notify_messages_consumed(self) -> Option<(u64)> {
        if let PrimaryEvent::OnNotifyMessagesConsumed { count } = self {
            Some((count))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_on_notify_memory_imported(self) -> Option<(u64)> {
        if let PrimaryEvent::OnNotifyMemoryImported { bytes } = self {
            Some((bytes))
        } else {
            None
        }
    }

    /// Decodes a message buffer as a [`PrimaryEvent`]. Transaction
    /// ID in the message must be zero; this method does not check TXID.
    fn decode(mut buf: fidl::MessageBufEtc) -> Result<PrimaryEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

        match tx_header.ordinal() {
            0x5e8dd0b0b753ac43 => {
                let mut out_tuple: (u64,) = fidl::encoding::Decodable::new_empty();
                fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/PrimaryOnNotifyMessagesConsumedEvent");
                fidl::trace_blob!("fidl:blob", "decode", bytes);
                if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW) {
                    return Err(fidl::Error::LargeMessageImpossible);
                }
                fidl::encoding::Decoder::decode_into(
                    &tx_header,
                    _body_bytes,
                    _handles,
                    &mut out_tuple,
                )?;
                fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => _handles.len() as u32);
                Ok((PrimaryEvent::OnNotifyMessagesConsumed { count: out_tuple.0 }))
            }
            0x50524b7a3503aba6 => {
                let mut out_tuple: (u64,) = fidl::encoding::Decodable::new_empty();
                fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/PrimaryOnNotifyMemoryImportedEvent");
                fidl::trace_blob!("fidl:blob", "decode", bytes);
                if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW) {
                    return Err(fidl::Error::LargeMessageImpossible);
                }
                fidl::encoding::Decoder::decode_into(
                    &tx_header,
                    _body_bytes,
                    _handles,
                    &mut out_tuple,
                )?;
                fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => _handles.len() as u32);
                Ok((PrimaryEvent::OnNotifyMemoryImported { bytes: out_tuple.0 }))
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal(),
                protocol_name: <PrimaryMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for Primary
pub struct PrimaryRequestStream {
    inner: std::sync::Arc<fidl::ServeInner>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for PrimaryRequestStream {
    type Protocol = PrimaryMarker;
    type ControlHandle = PrimaryControlHandle;

    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 {
        PrimaryControlHandle { inner: self.inner.clone() }
    }

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

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

impl futures::Stream for PrimaryRequestStream {
    type Item = Result<PrimaryRequest, 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.poll_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled PrimaryRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf(|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))))
                }
            }

            // A message has been received from the channel
            let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
            if !header.is_compatible() {
                return std::task::Poll::Ready(Some(Err(fidl::Error::IncompatibleMagicNumber(
                    header.magic_number(),
                ))));
            }

            std::task::Poll::Ready(Some(match header.ordinal() {
                0x774ef4bc434f6b40 => {
                    let mut req: (
                        HandleWrapperObjectTypeNONERights2147483648<fidl::Handle>,
                        ObjectType,
                        u64,
                    ) = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/PrimaryImportObject2Request");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = PrimaryControlHandle { inner: this.inner.clone() };

                    Ok(PrimaryRequest::ImportObject2 {
                        object: req.0.into_inner(),
                        object_type: req.1,
                        object_id: req.2,
                        control_handle,
                    })
                }
                0x4a65d5885da5e88f => {
                    let mut req: (u64, ObjectType) = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/PrimaryReleaseObjectRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = PrimaryControlHandle { inner: this.inner.clone() };

                    Ok(PrimaryRequest::ReleaseObject {
                        object_id: req.0,
                        object_type: req.1,
                        control_handle,
                    })
                }
                0x5a9a91c8b88b5da4 => {
                    let mut req: (u32,) = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/PrimaryCreateContextRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = PrimaryControlHandle { inner: this.inner.clone() };

                    Ok(PrimaryRequest::CreateContext { context_id: req.0, control_handle })
                }
                0x26b626e6be162ef0 => {
                    let mut req: (u32,) = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/PrimaryDestroyContextRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = PrimaryControlHandle { inner: this.inner.clone() };

                    Ok(PrimaryRequest::DestroyContext { context_id: req.0, control_handle })
                }
                0xf2799643aadb0db => {
                    let mut req: (
                        u32,
                        Vec<BufferRange>,
                        Vec<CommandBuffer>,
                        Vec<u64>,
                        Vec<u64>,
                        CommandBufferFlags,
                    ) = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/PrimaryExecuteCommandRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    fidl::encoding::maybe_overflowing_decode(
                        &header,
                        _body_bytes,
                        handles,
                        &mut req,
                    )?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = PrimaryControlHandle { inner: this.inner.clone() };

                    Ok(PrimaryRequest::ExecuteCommand {
                        context_id: req.0,
                        resources: req.1,
                        command_buffers: req.2,
                        wait_semaphores: req.3,
                        signal_semaphores: req.4,
                        flags: req.5,
                        control_handle,
                    })
                }
                0x3d7e0dcdbfd4b61f => {
                    let mut req: (u32, Vec<u8>, Vec<u64>) = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/PrimaryExecuteImmediateCommandsRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    fidl::encoding::maybe_overflowing_decode(
                        &header,
                        _body_bytes,
                        handles,
                        &mut req,
                    )?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = PrimaryControlHandle { inner: this.inner.clone() };

                    Ok(PrimaryRequest::ExecuteImmediateCommands {
                        context_id: req.0,
                        command_data: req.1,
                        semaphores: req.2,
                        control_handle,
                    })
                }
                0x54ccb5572d886039 => {
                    let mut req: () = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/PrimaryFlushRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = PrimaryControlHandle { inner: this.inner.clone() };

                    Ok(PrimaryRequest::Flush {
                        responder: PrimaryFlushResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id(),
                            ordinal: header.ordinal(),
                        },
                    })
                }
                0x56baa5d2092c8e33 => {
                    let mut req: (PrimaryMapBufferRequest,) =
                        fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/PrimaryMapBufferRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    fidl::encoding::maybe_overflowing_decode(
                        &header,
                        _body_bytes,
                        handles,
                        &mut req,
                    )?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = PrimaryControlHandle { inner: this.inner.clone() };

                    Ok(PrimaryRequest::MapBuffer { payload: req.0, control_handle })
                }
                0x305188ebd8bcd95c => {
                    let mut req: (PrimaryUnmapBufferRequest,) =
                        fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/PrimaryUnmapBufferRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    fidl::encoding::maybe_overflowing_decode(
                        &header,
                        _body_bytes,
                        handles,
                        &mut req,
                    )?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = PrimaryControlHandle { inner: this.inner.clone() };

                    Ok(PrimaryRequest::UnmapBuffer { payload: req.0, control_handle })
                }
                0x4175c8dfef355396 => {
                    let mut req: (BufferOp, BufferRange) = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/PrimaryBufferRangeOp2Request");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = PrimaryControlHandle { inner: this.inner.clone() };

                    Ok(PrimaryRequest::BufferRangeOp2 { op: req.0, range: req.1, control_handle })
                }
                0x8b5e68f3ee0b22e => {
                    let mut req: () = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/PrimaryEnableFlowControlRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = PrimaryControlHandle { inner: this.inner.clone() };

                    Ok(PrimaryRequest::EnableFlowControl { control_handle })
                }
                0x51b369ac16588831 => {
                    let mut req: (HandleWrapperObjectTypeEVENTRights2147483648<fidl::Event>,) =
                        fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/PrimaryEnablePerformanceCounterAccessRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = PrimaryControlHandle { inner: this.inner.clone() };

                    Ok(PrimaryRequest::EnablePerformanceCounterAccess {
                        access_token: req.0.into_inner(),
                        control_handle,
                    })
                }
                0x1933b70c06cc5702 => {
                    let mut req: () = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/PrimaryIsPerformanceCounterAccessAllowedRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = PrimaryControlHandle { inner: this.inner.clone() };

                    Ok(PrimaryRequest::IsPerformanceCounterAccessAllowed {
                        responder: PrimaryIsPerformanceCounterAccessAllowedResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id(),
                            ordinal: header.ordinal(),
                        },
                    })
                }
                0x52c4db74b601aaa7 => {
                    let mut req: (Vec<u64>,) = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/PrimaryEnablePerformanceCountersRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = PrimaryControlHandle { inner: this.inner.clone() };

                    Ok(PrimaryRequest::EnablePerformanceCounters {
                        counters: req.0,
                        control_handle,
                    })
                }
                0x48ccf6519bbbc638 => {
                    let mut req: (
                        u64,
                        HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT<
                            fidl::endpoints::ServerEnd<PerformanceCounterEventsMarker>,
                        >,
                    ) = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/PrimaryCreatePerformanceCounterBufferPoolRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = PrimaryControlHandle { inner: this.inner.clone() };

                    Ok(PrimaryRequest::CreatePerformanceCounterBufferPool {
                        pool_id: req.0,
                        event_channel: req.1.into_inner(),
                        control_handle,
                    })
                }
                0x18374c4b3ef0b4da => {
                    let mut req: (u64,) = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/PrimaryReleasePerformanceCounterBufferPoolRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = PrimaryControlHandle { inner: this.inner.clone() };

                    Ok(PrimaryRequest::ReleasePerformanceCounterBufferPool {
                        pool_id: req.0,
                        control_handle,
                    })
                }
                0x1f7889571111386b => {
                    let mut req: (u64, Vec<BufferRange>) = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/PrimaryAddPerformanceCounterBufferOffsetsToPoolRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = PrimaryControlHandle { inner: this.inner.clone() };

                    Ok(PrimaryRequest::AddPerformanceCounterBufferOffsetsToPool {
                        pool_id: req.0,
                        offsets: req.1,
                        control_handle,
                    })
                }
                0xbf1275f5a36258e => {
                    let mut req: (u64, u64) = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/PrimaryRemovePerformanceCounterBufferFromPoolRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = PrimaryControlHandle { inner: this.inner.clone() };

                    Ok(PrimaryRequest::RemovePerformanceCounterBufferFromPool {
                        pool_id: req.0,
                        buffer_id: req.1,
                        control_handle,
                    })
                }
                0x250b29340be28807 => {
                    let mut req: (u64, u32) = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/PrimaryDumpPerformanceCountersRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = PrimaryControlHandle { inner: this.inner.clone() };

                    Ok(PrimaryRequest::DumpPerformanceCounters {
                        pool_id: req.0,
                        trigger_id: req.1,
                        control_handle,
                    })
                }
                0x236831822eff741a => {
                    let mut req: (Vec<u64>,) = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/PrimaryClearPerformanceCountersRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = PrimaryControlHandle { inner: this.inner.clone() };

                    Ok(PrimaryRequest::ClearPerformanceCounters { counters: req.0, control_handle })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal(),
                    protocol_name: <PrimaryMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
        })
    }
}
/// If a system driver error occurs, or if the client sends a message that the client should have
/// known is invalid, the connection will be closed and a zx.status sent via epitaph.
#[derive(Debug)]
pub enum PrimaryRequest {
    /// Imports an object for use in the system driver.
    ImportObject2 {
        object: fidl::Handle,

        object_type: ObjectType,

        object_id: u64,
        control_handle: PrimaryControlHandle,
    },
    /// Destroys the object with `object_id` within this connection.
    ReleaseObject { object_id: u64, object_type: ObjectType, control_handle: PrimaryControlHandle },
    /// Creates context `context_id` for use in command execution.  A context may be associated
    /// with hardware state.
    CreateContext { context_id: u32, control_handle: PrimaryControlHandle },
    /// Destroys context `context_id`.
    DestroyContext { context_id: u32, control_handle: PrimaryControlHandle },
    /// Submits command buffers for execution on the hardware, with associated `resources`.
    /// `resources` must refer to buffers that have been imported.
    /// `wait_semaphores` and `signal_semaphores` must refer to events that have been imported.
    /// `wait_semaphores` must all be signaled before execution begins, then are reset.
    /// `signal_semaphores` will be signaled after the command buffer is completed.
    ExecuteCommand {
        context_id: u32,

        resources: Vec<BufferRange>,

        command_buffers: Vec<CommandBuffer>,

        wait_semaphores: Vec<u64>,

        signal_semaphores: Vec<u64>,

        flags: CommandBufferFlags,
        control_handle: PrimaryControlHandle,
    },
    /// Submits a series of commands for execution on the hardware without using a command buffer.
    /// `semaphores` must refer to events that have been imported, and will be signaled after
    /// the commands are completed.
    ExecuteImmediateCommands {
        context_id: u32,

        command_data: Vec<u8>,

        semaphores: Vec<u64>,
        control_handle: PrimaryControlHandle,
    },
    /// Incurs a round-trip to the system driver, used to ensure all previous messages have been
    /// observed, but not necessarily completed.
    Flush { responder: PrimaryFlushResponder },
    /// Maps a page range onto the hardware in the connection's address space at address `hw_va`.
    /// `flags` is a set of flags from MapFlags that specify how the hardware can access the buffer.
    MapBuffer { payload: PrimaryMapBufferRequest, control_handle: PrimaryControlHandle },
    /// Releases the mapping at address `hw_va` from the hardware for the given `buffer_id`.
    /// Buffers will also be implicitly unmapped when released.
    UnmapBuffer { payload: PrimaryUnmapBufferRequest, control_handle: PrimaryControlHandle },
    /// Perform an operation on a range of the buffer.
    BufferRangeOp2 { op: BufferOp, range: BufferRange, control_handle: PrimaryControlHandle },
    /// Enables the events OnNotifyMessagesConsumed and OnNotifyMemoryImported.
    EnableFlowControl { control_handle: PrimaryControlHandle },
    /// Tries to enable performance counter FIDL messages. To be successful, |access_token| must
    /// have been returned by PerformanceCounterAccess.GetPerformanceCountToken() from the matching
    /// device.
    EnablePerformanceCounterAccess {
        access_token: fidl::Event,
        control_handle: PrimaryControlHandle,
    },
    /// Returns true if any EnablePerformanceCounterAccess message has succeeded.
    IsPerformanceCounterAccessAllowed {
        responder: PrimaryIsPerformanceCounterAccessAllowedResponder,
    },
    /// Enables a set of performance counters.  Disables enabled performance counters that are not
    /// in the new set. Performance counters will also be automatically disabled on connection
    /// close. Performance counter access must have been enabled using
    /// EnablePerformanceCounterAccess before calling this method.
    EnablePerformanceCounters { counters: Vec<u64>, control_handle: PrimaryControlHandle },
    /// Creates a pool of buffers that performance counters can be dumped into. Performance counter
    /// access must have been enabled using EnablePerformanceCounterAccess before calling this
    /// method.
    CreatePerformanceCounterBufferPool {
        pool_id: u64,

        event_channel: fidl::endpoints::ServerEnd<PerformanceCounterEventsMarker>,
        control_handle: PrimaryControlHandle,
    },
    /// Releases a pool of performance counter buffers. Performance counter access must have been
    /// enabled using EnablePerformanceCounterAccess before calling this method.
    ReleasePerformanceCounterBufferPool { pool_id: u64, control_handle: PrimaryControlHandle },
    /// Adds a set of offsets into buffers to the pool. |offsets[n].buffer_id| is the id of a
    /// buffer that was previously imported using ImportBuffer(). The same buffer may be added to
    /// multiple pools. The pool will hold on to a reference to the buffer even after ReleaseBuffer
    /// is called.  When dumped into this entry, counters will be written starting at
    /// |offsets[n].buffer_offset| bytes into the buffer, and up to |offsets[n].buffer_offset| +
    /// |offsets[n].buffer_size|. |offsets[n].buffer_size| must be large enough to fit all enabled
    /// counters. Performance counter access must have been enabled using
    /// EnablePerformanceCounterAccess before calling this method.
    AddPerformanceCounterBufferOffsetsToPool {
        pool_id: u64,

        offsets: Vec<BufferRange>,
        control_handle: PrimaryControlHandle,
    },
    /// Removes every offset of a buffer from the pool. Once this method is finished being handled
    /// on the server, no more dumps will be processed into this buffer. In-flight dumps into this
    /// buffer may be lost.  Performance counter access must have been enabled using
    /// EnablePerformanceCounterAccess before calling this method.
    RemovePerformanceCounterBufferFromPool {
        pool_id: u64,

        buffer_id: u64,
        control_handle: PrimaryControlHandle,
    },
    /// Triggers dumping of the performance counters into a buffer pool. May fail silently if there
    /// are no buffers in the pool. |trigger_id| is an arbitrary ID assigned by the client that can
    /// be returned in OnPerformanceCounterReadCompleted. Performance counter access must have been
    /// enabled using EnablePerformanceCounterAccess before calling this method.
    DumpPerformanceCounters { pool_id: u64, trigger_id: u32, control_handle: PrimaryControlHandle },
    /// Sets the values of all listed performance counters to 0. May not be supported by some
    /// hardware. Performance counter access must have been enabled using
    /// EnablePerformanceCounterAccess before calling this method.
    ClearPerformanceCounters { counters: Vec<u64>, control_handle: PrimaryControlHandle },
}

impl PrimaryRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_import_object2(
        self,
    ) -> Option<(fidl::Handle, ObjectType, u64, PrimaryControlHandle)> {
        if let PrimaryRequest::ImportObject2 { object, object_type, object_id, control_handle } =
            self
        {
            Some((object, object_type, object_id, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_release_object(self) -> Option<(u64, ObjectType, PrimaryControlHandle)> {
        if let PrimaryRequest::ReleaseObject { object_id, object_type, control_handle } = self {
            Some((object_id, object_type, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_create_context(self) -> Option<(u32, PrimaryControlHandle)> {
        if let PrimaryRequest::CreateContext { context_id, control_handle } = self {
            Some((context_id, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_destroy_context(self) -> Option<(u32, PrimaryControlHandle)> {
        if let PrimaryRequest::DestroyContext { context_id, control_handle } = self {
            Some((context_id, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_execute_command(
        self,
    ) -> Option<(
        u32,
        Vec<BufferRange>,
        Vec<CommandBuffer>,
        Vec<u64>,
        Vec<u64>,
        CommandBufferFlags,
        PrimaryControlHandle,
    )> {
        if let PrimaryRequest::ExecuteCommand {
            context_id,

            resources,

            command_buffers,

            wait_semaphores,

            signal_semaphores,

            flags,
            control_handle,
        } = self
        {
            Some((
                context_id,
                resources,
                command_buffers,
                wait_semaphores,
                signal_semaphores,
                flags,
                control_handle,
            ))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_execute_immediate_commands(
        self,
    ) -> Option<(u32, Vec<u8>, Vec<u64>, PrimaryControlHandle)> {
        if let PrimaryRequest::ExecuteImmediateCommands {
            context_id,

            command_data,

            semaphores,
            control_handle,
        } = self
        {
            Some((context_id, command_data, semaphores, control_handle))
        } else {
            None
        }
    }

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_map_buffer(self) -> Option<(PrimaryMapBufferRequest, PrimaryControlHandle)> {
        if let PrimaryRequest::MapBuffer { payload, control_handle } = self {
            Some((payload, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_unmap_buffer(self) -> Option<(PrimaryUnmapBufferRequest, PrimaryControlHandle)> {
        if let PrimaryRequest::UnmapBuffer { payload, control_handle } = self {
            Some((payload, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_buffer_range_op2(self) -> Option<(BufferOp, BufferRange, PrimaryControlHandle)> {
        if let PrimaryRequest::BufferRangeOp2 { op, range, control_handle } = self {
            Some((op, range, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_enable_flow_control(self) -> Option<(PrimaryControlHandle)> {
        if let PrimaryRequest::EnableFlowControl { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_enable_performance_counter_access(
        self,
    ) -> Option<(fidl::Event, PrimaryControlHandle)> {
        if let PrimaryRequest::EnablePerformanceCounterAccess { access_token, control_handle } =
            self
        {
            Some((access_token, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_is_performance_counter_access_allowed(
        self,
    ) -> Option<(PrimaryIsPerformanceCounterAccessAllowedResponder)> {
        if let PrimaryRequest::IsPerformanceCounterAccessAllowed { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_enable_performance_counters(self) -> Option<(Vec<u64>, PrimaryControlHandle)> {
        if let PrimaryRequest::EnablePerformanceCounters { counters, control_handle } = self {
            Some((counters, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_create_performance_counter_buffer_pool(
        self,
    ) -> Option<(
        u64,
        fidl::endpoints::ServerEnd<PerformanceCounterEventsMarker>,
        PrimaryControlHandle,
    )> {
        if let PrimaryRequest::CreatePerformanceCounterBufferPool {
            pool_id,

            event_channel,
            control_handle,
        } = self
        {
            Some((pool_id, event_channel, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_release_performance_counter_buffer_pool(
        self,
    ) -> Option<(u64, PrimaryControlHandle)> {
        if let PrimaryRequest::ReleasePerformanceCounterBufferPool { pool_id, control_handle } =
            self
        {
            Some((pool_id, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_performance_counter_buffer_offsets_to_pool(
        self,
    ) -> Option<(u64, Vec<BufferRange>, PrimaryControlHandle)> {
        if let PrimaryRequest::AddPerformanceCounterBufferOffsetsToPool {
            pool_id,

            offsets,
            control_handle,
        } = self
        {
            Some((pool_id, offsets, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_remove_performance_counter_buffer_from_pool(
        self,
    ) -> Option<(u64, u64, PrimaryControlHandle)> {
        if let PrimaryRequest::RemovePerformanceCounterBufferFromPool {
            pool_id,

            buffer_id,
            control_handle,
        } = self
        {
            Some((pool_id, buffer_id, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_dump_performance_counters(self) -> Option<(u64, u32, PrimaryControlHandle)> {
        if let PrimaryRequest::DumpPerformanceCounters { pool_id, trigger_id, control_handle } =
            self
        {
            Some((pool_id, trigger_id, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_clear_performance_counters(self) -> Option<(Vec<u64>, PrimaryControlHandle)> {
        if let PrimaryRequest::ClearPerformanceCounters { counters, control_handle } = self {
            Some((counters, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            PrimaryRequest::ImportObject2 { .. } => "import_object2",
            PrimaryRequest::ReleaseObject { .. } => "release_object",
            PrimaryRequest::CreateContext { .. } => "create_context",
            PrimaryRequest::DestroyContext { .. } => "destroy_context",
            PrimaryRequest::ExecuteCommand { .. } => "execute_command",
            PrimaryRequest::ExecuteImmediateCommands { .. } => "execute_immediate_commands",
            PrimaryRequest::Flush { .. } => "flush",
            PrimaryRequest::MapBuffer { .. } => "map_buffer",
            PrimaryRequest::UnmapBuffer { .. } => "unmap_buffer",
            PrimaryRequest::BufferRangeOp2 { .. } => "buffer_range_op2",
            PrimaryRequest::EnableFlowControl { .. } => "enable_flow_control",
            PrimaryRequest::EnablePerformanceCounterAccess { .. } => {
                "enable_performance_counter_access"
            }
            PrimaryRequest::IsPerformanceCounterAccessAllowed { .. } => {
                "is_performance_counter_access_allowed"
            }
            PrimaryRequest::EnablePerformanceCounters { .. } => "enable_performance_counters",
            PrimaryRequest::CreatePerformanceCounterBufferPool { .. } => {
                "create_performance_counter_buffer_pool"
            }
            PrimaryRequest::ReleasePerformanceCounterBufferPool { .. } => {
                "release_performance_counter_buffer_pool"
            }
            PrimaryRequest::AddPerformanceCounterBufferOffsetsToPool { .. } => {
                "add_performance_counter_buffer_offsets_to_pool"
            }
            PrimaryRequest::RemovePerformanceCounterBufferFromPool { .. } => {
                "remove_performance_counter_buffer_from_pool"
            }
            PrimaryRequest::DumpPerformanceCounters { .. } => "dump_performance_counters",
            PrimaryRequest::ClearPerformanceCounters { .. } => "clear_performance_counters",
        }
    }
}

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

impl fidl::endpoints::ControlHandle for PrimaryControlHandle {
    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<'a>(&'a self) -> fidl::OnSignals<'a> {
        self.inner.channel().on_closed()
    }
}

impl PrimaryControlHandle {
    pub fn send_on_notify_messages_consumed(&self, mut count: u64) -> Result<(), fidl::Error> {
        let mut response = (count);
        self.inner.send::<_, false>(
            &mut response,
            0,
            0x5e8dd0b0b753ac43,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_on_notify_memory_imported(&self, mut bytes: u64) -> Result<(), fidl::Error> {
        let mut response = (bytes);
        self.inner.send::<_, false>(
            &mut response,
            0,
            0x50524b7a3503aba6,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct PrimaryFlushResponder {
    control_handle: std::mem::ManuallyDrop<PrimaryControlHandle>,
    tx_id: u32,
    ordinal: u64,
}

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

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

    /// 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 r = self.send_raw();
        self.drop_without_shutdown();
        r
    }

    fn send_raw(&self) -> Result<(), fidl::Error> {
        let mut response = (());

        let mut msg = fidl::encoding::TransactionMessage {
            header: fidl::encoding::TransactionHeader::new(
                self.tx_id,
                self.ordinal,
                fidl::encoding::DynamicFlags::empty(),
            ),
            body: &mut response,
        };

        fidl::encoding::with_tls_encode_buf(|bytes, handles| {
            fidl::duration_begin!("fidl", "encode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/PrimaryFlushResponse");
            fidl::encoding::Encoder::encode(bytes, handles, &mut msg)?;
            fidl::trace_blob!("fidl:blob", "encode", bytes.as_slice());
            fidl::duration_end!("fidl", "encode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);

            self.control_handle.inner.send_raw_msg(&*bytes, &mut *handles)
        })
    }
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct PrimaryIsPerformanceCounterAccessAllowedResponder {
    control_handle: std::mem::ManuallyDrop<PrimaryControlHandle>,
    tx_id: u32,
    ordinal: u64,
}

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

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

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

    fn send_raw(&self, mut enabled: bool) -> Result<(), fidl::Error> {
        let mut response = (enabled);

        let mut msg = fidl::encoding::TransactionMessage {
            header: fidl::encoding::TransactionHeader::new(
                self.tx_id,
                self.ordinal,
                fidl::encoding::DynamicFlags::empty(),
            ),
            body: &mut response,
        };

        fidl::encoding::with_tls_encode_buf(|bytes, handles| {
            fidl::duration_begin!("fidl", "encode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/PrimaryIsPerformanceCounterAccessAllowedResponse");
            fidl::encoding::Encoder::encode(bytes, handles, &mut msg)?;
            fidl::trace_blob!("fidl:blob", "encode", bytes.as_slice());
            fidl::duration_end!("fidl", "encode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);

            self.control_handle.inner.send_raw_msg(&*bytes, &mut *handles)
        })
    }
}

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

impl fidl::endpoints::ProtocolMarker for TestDeviceMarker {
    type Proxy = TestDeviceProxy;
    type RequestStream = TestDeviceRequestStream;
    const DEBUG_NAME: &'static str = "(anonymous) TestDevice";
}

pub trait TestDeviceProxyInterface: Send + Sync {
    type QueryResponseFut: std::future::Future<Output = Result<(DeviceQueryResult), fidl::Error>>
        + Send;
    fn r#query(&self, query_id: QueryId) -> Self::QueryResponseFut;
    fn r#connect2(
        &self,
        client_id: u64,
        primary_channel: fidl::endpoints::ServerEnd<PrimaryMarker>,
        notification_channel: fidl::endpoints::ServerEnd<NotificationMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#dump_state(&self, dump_type: u32) -> Result<(), fidl::Error>;
    type GetIcdListResponseFut: std::future::Future<Output = Result<(Vec<IcdInfo>), fidl::Error>>
        + Send;
    fn r#get_icd_list(&self) -> Self::GetIcdListResponseFut;
    type GetUnitTestStatusResponseFut: std::future::Future<Output = Result<(i32), fidl::Error>>
        + Send;
    fn r#get_unit_test_status(&self) -> Self::GetUnitTestStatusResponseFut;
}

#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct TestDeviceSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl TestDeviceSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <TestDeviceMarker 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::Time) -> Result<TestDeviceEvent, fidl::Error> {
        TestDeviceEvent::decode(self.client.wait_for_event(deadline)?)
    }
    /// On success, returns a result either in a buffer or a simple value.
    pub fn r#query(
        &self,
        mut query_id: QueryId,
        ___deadline: zx::Time,
    ) -> Result<(DeviceQueryResult), fidl::Error> {
        let _value: DeviceQueryResultHandleWrapper = self.client.send_query::<_, _, false, false>(
            &mut (query_id),
            0x627d4c6093b078e7,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_value.map(|_value| _value.0))
    }
    /// Creates a connection to the device comprised of two IPC channels.
    /// The primary channel is for the Primary protocol (see below).  The notification channel is
    /// used for vendor-specific messages which are sent only in the reverse (server-client)
    /// direction, typically in response to client command completion.
    pub fn r#connect2(
        &self,
        mut client_id: u64,
        mut primary_channel: fidl::endpoints::ServerEnd<PrimaryMarker>,
        mut notification_channel: fidl::endpoints::ServerEnd<NotificationMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (
                client_id,
                HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT::<
                    fidl::endpoints::ServerEnd<PrimaryMarker>,
                >(primary_channel),
                HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT::<
                    fidl::endpoints::ServerEnd<NotificationMarker>,
                >(notification_channel),
            ),
            0x3a5b134714c67914,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    /// Dumps driver and hardware state to the log.
    pub fn r#dump_state(&self, mut dump_type: u32) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (dump_type,),
            0x5420df493d4fa915,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    /// Returns a list of ICDs that can be used with this Magma device. The list is sorted in
    /// descending order of preference.
    pub fn r#get_icd_list(&self, ___deadline: zx::Time) -> Result<(Vec<IcdInfo>), fidl::Error> {
        let _value: (Vec<IcdInfo>,) = self.client.send_query::<_, _, false, true>(
            &mut (),
            0x7673e76395008257,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_value.0)
    }
    pub fn r#get_unit_test_status(&self, ___deadline: zx::Time) -> Result<(i32), fidl::Error> {
        let _value: (i32,) = self.client.send_query::<_, _, false, false>(
            &mut (),
            0x3ebcd9c409c248f1,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_value.0)
    }
}

#[derive(Debug, Clone)]
pub struct TestDeviceProxy {
    client: fidl::client::Client,
}

impl fidl::endpoints::Proxy for TestDeviceProxy {
    type Protocol = TestDeviceMarker;

    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 TestDeviceProxy {
    /// Create a new Proxy for TestDevice
    pub fn new(channel: fidl::AsyncChannel) -> Self {
        let protocol_name = <TestDeviceMarker 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 TestDevice protocol
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> TestDeviceEventStream {
        TestDeviceEventStream { event_receiver: self.client.take_event_receiver() }
    }
    /// On success, returns a result either in a buffer or a simple value.
    pub fn r#query(
        &self,
        mut query_id: QueryId,
    ) -> fidl::client::QueryResponseFut<(DeviceQueryResult)> {
        TestDeviceProxyInterface::r#query(self, query_id)
    }
    /// Creates a connection to the device comprised of two IPC channels.
    /// The primary channel is for the Primary protocol (see below).  The notification channel is
    /// used for vendor-specific messages which are sent only in the reverse (server-client)
    /// direction, typically in response to client command completion.
    pub fn r#connect2(
        &self,
        mut client_id: u64,
        mut primary_channel: fidl::endpoints::ServerEnd<PrimaryMarker>,
        mut notification_channel: fidl::endpoints::ServerEnd<NotificationMarker>,
    ) -> Result<(), fidl::Error> {
        TestDeviceProxyInterface::r#connect2(self, client_id, primary_channel, notification_channel)
    }
    /// Dumps driver and hardware state to the log.
    pub fn r#dump_state(&self, mut dump_type: u32) -> Result<(), fidl::Error> {
        TestDeviceProxyInterface::r#dump_state(self, dump_type)
    }
    /// Returns a list of ICDs that can be used with this Magma device. The list is sorted in
    /// descending order of preference.
    pub fn r#get_icd_list(&self) -> fidl::client::QueryResponseFut<(Vec<IcdInfo>)> {
        TestDeviceProxyInterface::r#get_icd_list(self)
    }
    pub fn r#get_unit_test_status(&self) -> fidl::client::QueryResponseFut<(i32)> {
        TestDeviceProxyInterface::r#get_unit_test_status(self)
    }
}

impl TestDeviceProxyInterface for TestDeviceProxy {
    type QueryResponseFut = fidl::client::QueryResponseFut<(DeviceQueryResult)>;
    fn r#query(&self, mut query_id: QueryId) -> Self::QueryResponseFut {
        fn transform(
            result: Result<DeviceQueryResultHandleWrapper, fidl::Error>,
        ) -> Result<(DeviceQueryResult), fidl::Error> {
            result.map(|_value| _value.map(|_value| _value.0))
        }
        let send_result = self.client.call_send_raw_query::<_, false>(
            &mut (query_id),
            0x627d4c6093b078e7,
            fidl::encoding::DynamicFlags::empty(),
        );
        QueryResponseFut(match send_result {
            Ok(res_fut) => future::maybe_done(
                res_fut.and_then(|buf| decode_transaction_body_fut::<_, _, false>(buf, transform)),
            ),
            Err(e) => MaybeDone::Done(Err(e)),
        })
    }
    fn r#connect2(
        &self,
        mut client_id: u64,
        mut primary_channel: fidl::endpoints::ServerEnd<PrimaryMarker>,
        mut notification_channel: fidl::endpoints::ServerEnd<NotificationMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (
                client_id,
                HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT::<
                    fidl::endpoints::ServerEnd<PrimaryMarker>,
                >(primary_channel),
                HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT::<
                    fidl::endpoints::ServerEnd<NotificationMarker>,
                >(notification_channel),
            ),
            0x3a5b134714c67914,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    fn r#dump_state(&self, mut dump_type: u32) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (dump_type),
            0x5420df493d4fa915,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    type GetIcdListResponseFut = fidl::client::QueryResponseFut<(Vec<IcdInfo>)>;
    fn r#get_icd_list(&self) -> Self::GetIcdListResponseFut {
        fn transform(
            result: Result<(Vec<IcdInfo>,), fidl::Error>,
        ) -> Result<(Vec<IcdInfo>), fidl::Error> {
            result.map(|_value| _value.0)
        }
        let send_result = self.client.call_send_raw_query::<_, false>(
            &mut (),
            0x7673e76395008257,
            fidl::encoding::DynamicFlags::empty(),
        );
        QueryResponseFut(match send_result {
            Ok(res_fut) => future::maybe_done(
                res_fut.and_then(|buf| decode_transaction_body_fut::<_, _, true>(buf, transform)),
            ),
            Err(e) => MaybeDone::Done(Err(e)),
        })
    }
    type GetUnitTestStatusResponseFut = fidl::client::QueryResponseFut<(i32)>;
    fn r#get_unit_test_status(&self) -> Self::GetUnitTestStatusResponseFut {
        fn transform(result: Result<(i32,), fidl::Error>) -> Result<(i32), fidl::Error> {
            result.map(|_value| _value.0)
        }
        let send_result = self.client.call_send_raw_query::<_, false>(
            &mut (),
            0x3ebcd9c409c248f1,
            fidl::encoding::DynamicFlags::empty(),
        );
        QueryResponseFut(match send_result {
            Ok(res_fut) => future::maybe_done(
                res_fut.and_then(|buf| decode_transaction_body_fut::<_, _, false>(buf, transform)),
            ),
            Err(e) => MaybeDone::Done(Err(e)),
        })
    }
}

pub struct TestDeviceEventStream {
    event_receiver: fidl::client::EventReceiver,
}

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

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

impl futures::Stream for TestDeviceEventStream {
    type Item = Result<TestDeviceEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let buf = match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => buf,
            None => return std::task::Poll::Ready(None),
        };

        std::task::Poll::Ready(Some(TestDeviceEvent::decode(buf)))
    }
}

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

impl TestDeviceEvent {
    /// Decodes a message buffer as a [`TestDeviceEvent`]. Transaction
    /// ID in the message must be zero; this method does not check TXID.
    fn decode(mut buf: fidl::MessageBufEtc) -> Result<TestDeviceEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

        match tx_header.ordinal() {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal(),
                protocol_name: <TestDeviceMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for TestDevice
pub struct TestDeviceRequestStream {
    inner: std::sync::Arc<fidl::ServeInner>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for TestDeviceRequestStream {
    type Protocol = TestDeviceMarker;
    type ControlHandle = TestDeviceControlHandle;

    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 {
        TestDeviceControlHandle { inner: self.inner.clone() }
    }

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

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

impl futures::Stream for TestDeviceRequestStream {
    type Item = Result<TestDeviceRequest, 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.poll_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled TestDeviceRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf(|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))))
                }
            }

            // A message has been received from the channel
            let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
            if !header.is_compatible() {
                return std::task::Poll::Ready(Some(Err(fidl::Error::IncompatibleMagicNumber(
                    header.magic_number(),
                ))));
            }

            std::task::Poll::Ready(Some(match header.ordinal() {
                0x627d4c6093b078e7 => {
                    let mut req: (QueryId,) = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/TestDeviceQueryRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = TestDeviceControlHandle { inner: this.inner.clone() };

                    Ok(TestDeviceRequest::Query {
                        query_id: req.0,
                        responder: TestDeviceQueryResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id(),
                            ordinal: header.ordinal(),
                        },
                    })
                }
                0x3a5b134714c67914 => {
                    let mut req: (
                        u64,
                        HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT<
                            fidl::endpoints::ServerEnd<PrimaryMarker>,
                        >,
                        HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT<
                            fidl::endpoints::ServerEnd<NotificationMarker>,
                        >,
                    ) = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/TestDeviceConnect2Request");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = TestDeviceControlHandle { inner: this.inner.clone() };

                    Ok(TestDeviceRequest::Connect2 {
                        client_id: req.0,
                        primary_channel: req.1.into_inner(),
                        notification_channel: req.2.into_inner(),
                        control_handle,
                    })
                }
                0x5420df493d4fa915 => {
                    let mut req: (u32,) = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/TestDeviceDumpStateRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = TestDeviceControlHandle { inner: this.inner.clone() };

                    Ok(TestDeviceRequest::DumpState { dump_type: req.0, control_handle })
                }
                0x7673e76395008257 => {
                    let mut req: () = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/TestDeviceGetIcdListRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = TestDeviceControlHandle { inner: this.inner.clone() };

                    Ok(TestDeviceRequest::GetIcdList {
                        responder: TestDeviceGetIcdListResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id(),
                            ordinal: header.ordinal(),
                        },
                    })
                }
                0x3ebcd9c409c248f1 => {
                    let mut req: () = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/TestDeviceGetUnitTestStatusRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = TestDeviceControlHandle { inner: this.inner.clone() };

                    Ok(TestDeviceRequest::GetUnitTestStatus {
                        responder: TestDeviceGetUnitTestStatusResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id(),
                            ordinal: header.ordinal(),
                        },
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal(),
                    protocol_name:
                        <TestDeviceMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
        })
    }
}
/// Additional device methods for the purposes of testing the MSD and should not be used by ICDs.
#[derive(Debug)]
pub enum TestDeviceRequest {
    /// On success, returns a result either in a buffer or a simple value.
    Query {
        query_id: QueryId,
        responder: TestDeviceQueryResponder,
    },
    /// Creates a connection to the device comprised of two IPC channels.
    /// The primary channel is for the Primary protocol (see below).  The notification channel is
    /// used for vendor-specific messages which are sent only in the reverse (server-client)
    /// direction, typically in response to client command completion.
    Connect2 {
        client_id: u64,

        primary_channel: fidl::endpoints::ServerEnd<PrimaryMarker>,

        notification_channel: fidl::endpoints::ServerEnd<NotificationMarker>,
        control_handle: TestDeviceControlHandle,
    },
    /// Dumps driver and hardware state to the log.
    DumpState {
        dump_type: u32,
        control_handle: TestDeviceControlHandle,
    },
    /// Returns a list of ICDs that can be used with this Magma device. The list is sorted in
    /// descending order of preference.
    GetIcdList {
        responder: TestDeviceGetIcdListResponder,
    },
    GetUnitTestStatus {
        responder: TestDeviceGetUnitTestStatusResponder,
    },
}

impl TestDeviceRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_query(self) -> Option<(QueryId, TestDeviceQueryResponder)> {
        if let TestDeviceRequest::Query { query_id, responder } = self {
            Some((query_id, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_connect2(
        self,
    ) -> Option<(
        u64,
        fidl::endpoints::ServerEnd<PrimaryMarker>,
        fidl::endpoints::ServerEnd<NotificationMarker>,
        TestDeviceControlHandle,
    )> {
        if let TestDeviceRequest::Connect2 {
            client_id,

            primary_channel,

            notification_channel,
            control_handle,
        } = self
        {
            Some((client_id, primary_channel, notification_channel, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_dump_state(self) -> Option<(u32, TestDeviceControlHandle)> {
        if let TestDeviceRequest::DumpState { dump_type, control_handle } = self {
            Some((dump_type, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_icd_list(self) -> Option<(TestDeviceGetIcdListResponder)> {
        if let TestDeviceRequest::GetIcdList { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_unit_test_status(self) -> Option<(TestDeviceGetUnitTestStatusResponder)> {
        if let TestDeviceRequest::GetUnitTestStatus { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            TestDeviceRequest::Query { .. } => "query",
            TestDeviceRequest::Connect2 { .. } => "connect2",
            TestDeviceRequest::DumpState { .. } => "dump_state",
            TestDeviceRequest::GetIcdList { .. } => "get_icd_list",
            TestDeviceRequest::GetUnitTestStatus { .. } => "get_unit_test_status",
        }
    }
}

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

impl fidl::endpoints::ControlHandle for TestDeviceControlHandle {
    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<'a>(&'a self) -> fidl::OnSignals<'a> {
        self.inner.channel().on_closed()
    }
}

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

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

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

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

    fn send_raw(&self, mut _result: &mut DeviceQueryResult) -> Result<(), fidl::Error> {
        let mut response = (_result);

        let mut msg = fidl::encoding::TransactionMessage {
            header: fidl::encoding::TransactionHeader::new(
                self.tx_id,
                self.ordinal,
                fidl::encoding::DynamicFlags::empty(),
            ),
            body: &mut response,
        };

        fidl::encoding::with_tls_encode_buf(|bytes, handles| {
            fidl::duration_begin!("fidl", "encode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/TestDeviceQueryResponse");
            fidl::encoding::Encoder::encode(bytes, handles, &mut msg)?;
            fidl::trace_blob!("fidl:blob", "encode", bytes.as_slice());
            fidl::duration_end!("fidl", "encode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);

            self.control_handle.inner.send_raw_msg(&*bytes, &mut *handles)
        })
    }
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct TestDeviceGetIcdListResponder {
    control_handle: std::mem::ManuallyDrop<TestDeviceControlHandle>,
    tx_id: u32,
    ordinal: u64,
}

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

    fn control_handle(&self) -> &TestDeviceControlHandle {
        &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 TestDeviceGetIcdListResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut icd_list: &mut dyn ExactSizeIterator<Item = IcdInfo>,
    ) -> Result<(), fidl::Error> {
        let r = self.send_raw(icd_list);
        if r.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        r
    }

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

    fn send_raw(
        &self,
        mut icd_list: &mut dyn ExactSizeIterator<Item = IcdInfo>,
    ) -> Result<(), fidl::Error> {
        let mut response = (icd_list);

        let mut msg = fidl::encoding::TransactionMessage {
            header: fidl::encoding::TransactionHeader::new(
                self.tx_id,
                self.ordinal,
                fidl::encoding::DynamicFlags::empty(),
            ),
            body: &mut response,
        };

        fidl::encoding::with_tls_encode_buf(|bytes, handles| {
            fidl::duration_begin!("fidl", "encode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/TestDeviceGetIcdListResponse");
            fidl::encoding::Encoder::encode(bytes, handles, &mut msg)?;
            fidl::trace_blob!("fidl:blob", "encode", bytes.as_slice());
            fidl::duration_end!("fidl", "encode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);

            self.control_handle.inner.send_raw_msg(&*bytes, &mut *handles)
        })
    }
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct TestDeviceGetUnitTestStatusResponder {
    control_handle: std::mem::ManuallyDrop<TestDeviceControlHandle>,
    tx_id: u32,
    ordinal: u64,
}

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

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

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

    fn send_raw(&self, mut status: i32) -> Result<(), fidl::Error> {
        let mut response = (status);

        let mut msg = fidl::encoding::TransactionMessage {
            header: fidl::encoding::TransactionHeader::new(
                self.tx_id,
                self.ordinal,
                fidl::encoding::DynamicFlags::empty(),
            ),
            body: &mut response,
        };

        fidl::encoding::with_tls_encode_buf(|bytes, handles| {
            fidl::duration_begin!("fidl", "encode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.gpu.magma/TestDeviceGetUnitTestStatusResponse");
            fidl::encoding::Encoder::encode(bytes, handles, &mut msg)?;
            fidl::trace_blob!("fidl:blob", "encode", bytes.as_slice());
            fidl::duration_end!("fidl", "encode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);

            self.control_handle.inner.send_raw_msg(&*bytes, &mut *handles)
        })
    }
}