fidl_fuchsia_gpu_magma/

fidl_fuchsia_gpu_magma.rs

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

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

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DependencyInjectionSetMemoryPressureProviderRequest {
    pub provider: fidl::endpoints::ClientEnd<fidl_fuchsia_memorypressure::ProviderMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DeviceConnect2Request {
    pub client_id: u64,
    pub primary_channel: fidl::endpoints::ServerEnd<PrimaryMarker>,
    pub notification_channel: fidl::endpoints::ServerEnd<NotificationMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct PerformanceCounterAccessGetPerformanceCountTokenResponse {
    pub access_token: fidl::Event,
}

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

#[derive(Debug, PartialEq)]
pub struct PowerElementProviderGetPowerGoalsResponse {
    pub goals: Vec<PowerGoal>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct PrimaryCreatePerformanceCounterBufferPoolRequest {
    pub pool_id: u64,
    pub event_channel: fidl::endpoints::ServerEnd<PerformanceCounterEventsMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct PrimaryEnablePerformanceCounterAccessRequest {
    pub access_token: fidl::Event,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct PowerElementProviderGetClockSpeedLevelResponse {
    /// Required. The fuchsia.power.broker.DependencyToken that must be leased.
    pub token: Option<fidl::Event>,
    /// Required. The level to lease `token` at.
    pub level: Option<u8>,
    /// Required. The target frequency that the level represents. If `allow_max==false' (or
    /// allow_max isn't set) then this must be >= `hz`; otherwise, it can be any value relative
    /// to `hz`.
    pub actual_hz: Option<u64>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct PowerElementProviderSetClockLimitResponse {
    /// Required. A handle representing this request; the clock limit will be honored as long as
    /// the handle is open.
    pub handle: Option<fidl::EventPair>,
    /// Required. The actual frequency the clock is limited to. This may be more or less than
    /// `hz`.
    pub actual_hz: Option<u64>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

/// This table represents a specific power goal. The client must acquire a lease on the token to
/// activate the state.
#[derive(Debug, Default, PartialEq)]
pub struct PowerGoal {
    /// Required.
    pub type_: Option<PowerGoalType>,
    /// Required. The fuchsia.power.broker.DependencyToken that must be leased at level 1 to achieve
    /// the goal.
    pub token: Option<fidl::Event>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct PrimaryImportObjectRequest {
    /// Required.
    pub object: Option<Object>,
    /// Required.
    pub object_type: Option<ObjectType>,
    /// Required.
    pub object_id: Option<u64>,
    /// Optional
    pub flags: Option<ImportFlags>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

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

impl DeviceQueryResponse {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::SimpleResult(_) => 1,
            Self::BufferResult(_) => 2,
        }
    }
}

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

#[derive(Debug)]
pub enum Object {
    Semaphore(fidl::Event),
    Buffer(fidl::Vmo),
    VmoSemaphore(fidl::Vmo),
    CounterSemaphore(fidl::Counter),
    #[doc(hidden)]
    __SourceBreaking {
        unknown_ordinal: u64,
    },
}

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

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

impl Object {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::Semaphore(_) => 1,
            Self::Buffer(_) => 2,
            Self::VmoSemaphore(_) => 3,
            Self::CounterSemaphore(_) => 4,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

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

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

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

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

impl fidl::endpoints::ProtocolMarker for CombinedDeviceMarker {
    type Proxy = CombinedDeviceProxy;
    type RequestStream = CombinedDeviceRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = CombinedDeviceSynchronousProxy;

    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 fidl::endpoints::SynchronousProxy for CombinedDeviceSynchronousProxy {
    type Proxy = CombinedDeviceProxy;
    type Protocol = CombinedDeviceMarker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl 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::MonotonicInstant,
    ) -> 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::MonotonicInstant,
    ) -> Result<DeviceQueryResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<DeviceQueryRequest, fidl::encoding::ResultType<DeviceQueryResponse, i32>>(
                (query_id,),
                0x627d4c6093b078e7,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// 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::<DeviceConnect2Request>(
            (client_id, primary_channel, 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::<DiagnosticDeviceDumpStateRequest>(
            (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::MonotonicInstant,
    ) -> Result<Vec<IcdInfo>, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, IcdLoaderDeviceGetIcdListResponse>(
                (),
                0x7673e76395008257,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.icd_list)
    }
}

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

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

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

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

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

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 fuchsia.gpu.magma/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 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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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>, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        CombinedDeviceProxyInterface::r#get_icd_list(self)
    }
}

impl CombinedDeviceProxyInterface for CombinedDeviceProxy {
    type QueryResponseFut = fidl::client::QueryResponseFut<
        DeviceQueryResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#query(&self, mut query_id: QueryId) -> Self::QueryResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceQueryResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<DeviceQueryResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x627d4c6093b078e7,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<DeviceQueryRequest, DeviceQueryResult>(
            (query_id,),
            0x627d4c6093b078e7,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    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::<DeviceConnect2Request>(
            (client_id, primary_channel, notification_channel),
            0x3a5b134714c67914,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

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

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

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>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(CombinedDeviceEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

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

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

/// A Stream of incoming requests for fuchsia.gpu.magma/CombinedDevice.
pub struct CombinedDeviceRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    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<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x627d4c6093b078e7 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceQueryRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceQueryRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            CombinedDeviceControlHandle { inner: this.inner.clone() };
                        Ok(CombinedDeviceRequest::Query {
                            query_id: req.query_id,

                            responder: CombinedDeviceQueryResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3a5b134714c67914 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceConnect2Request,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceConnect2Request>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            CombinedDeviceControlHandle { inner: this.inner.clone() };
                        Ok(CombinedDeviceRequest::Connect2 {
                            client_id: req.client_id,
                            primary_channel: req.primary_channel,
                            notification_channel: req.notification_channel,

                            control_handle,
                        })
                    }
                    0x5420df493d4fa915 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            DiagnosticDeviceDumpStateRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DiagnosticDeviceDumpStateRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            CombinedDeviceControlHandle { inner: this.inner.clone() };
                        Ok(CombinedDeviceRequest::DumpState {
                            dump_type: req.dump_type,

                            control_handle,
                        })
                    }
                    0x7673e76395008257 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            CombinedDeviceControlHandle { inner: this.inner.clone() };
                        Ok(CombinedDeviceRequest::GetIcdList {
                            responder: CombinedDeviceGetIcdListResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => 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<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

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(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

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

impl 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,
}

/// 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: Result<DeviceQueryResponse, i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

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

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

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

/// 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: &[IcdInfo]) -> Result<(), fidl::Error> {
        let _result = self.send_raw(icd_list);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

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

    fn send_raw(&self, mut icd_list: &[IcdInfo]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<IcdLoaderDeviceGetIcdListResponse>(
            (icd_list,),
            self.tx_id,
            0x7673e76395008257,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for DebugUtilsMarker {
    type Proxy = DebugUtilsProxy;
    type RequestStream = DebugUtilsRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = DebugUtilsSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) DebugUtils";
}
pub type DebugUtilsSetPowerStateResult = Result<u64, i32>;

pub trait DebugUtilsProxyInterface: Send + Sync {
    type SetPowerStateResponseFut: std::future::Future<Output = Result<DebugUtilsSetPowerStateResult, fidl::Error>>
        + Send;
    fn r#set_power_state(&self, power_state: i64) -> Self::SetPowerStateResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct DebugUtilsSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for DebugUtilsSynchronousProxy {
    type Proxy = DebugUtilsProxy;
    type Protocol = DebugUtilsMarker;

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

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

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

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

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

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

    /// Set the GPU power state. Returns after the transition is complete.
    pub fn r#set_power_state(
        &self,
        mut power_state: i64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DebugUtilsSetPowerStateResult, fidl::Error> {
        let _response = self.client.send_query::<
            DebugUtilsSetPowerStateRequest,
            fidl::encoding::ResultType<DebugUtilsSetPowerStateResponse, i32>,
        >(
            (power_state,),
            0x1db4f4bbbf7fb866,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.time_in_ns))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for DebugUtilsProxy {
    type Protocol = DebugUtilsMarker;

    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 DebugUtilsProxy {
    /// Create a new Proxy for fuchsia.gpu.magma/DebugUtils.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <DebugUtilsMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

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

    /// Set the GPU power state. Returns after the transition is complete.
    pub fn r#set_power_state(
        &self,
        mut power_state: i64,
    ) -> fidl::client::QueryResponseFut<
        DebugUtilsSetPowerStateResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DebugUtilsProxyInterface::r#set_power_state(self, power_state)
    }
}

impl DebugUtilsProxyInterface for DebugUtilsProxy {
    type SetPowerStateResponseFut = fidl::client::QueryResponseFut<
        DebugUtilsSetPowerStateResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_power_state(&self, mut power_state: i64) -> Self::SetPowerStateResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DebugUtilsSetPowerStateResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<DebugUtilsSetPowerStateResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1db4f4bbbf7fb866,
            >(_buf?)?;
            Ok(_response.map(|x| x.time_in_ns))
        }
        self.client
            .send_query_and_decode::<DebugUtilsSetPowerStateRequest, DebugUtilsSetPowerStateResult>(
                (power_state,),
                0x1db4f4bbbf7fb866,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }
}

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

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.gpu.magma/DebugUtils.
pub struct DebugUtilsRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for DebugUtilsRequestStream {
    type Protocol = DebugUtilsMarker;
    type ControlHandle = DebugUtilsControlHandle;

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

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

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

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

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled DebugUtilsRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x1db4f4bbbf7fb866 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DebugUtilsSetPowerStateRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DebugUtilsSetPowerStateRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DebugUtilsControlHandle { inner: this.inner.clone() };
                        Ok(DebugUtilsRequest::SetPowerState {
                            power_state: req.power_state,

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

/// Low-level protocol exposed by the GPU driver used mainly for testing and debugging the driver.
#[derive(Debug)]
pub enum DebugUtilsRequest {
    /// Set the GPU power state. Returns after the transition is complete.
    SetPowerState { power_state: i64, responder: DebugUtilsSetPowerStateResponder },
}

impl DebugUtilsRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_set_power_state(self) -> Option<(i64, DebugUtilsSetPowerStateResponder)> {
        if let DebugUtilsRequest::SetPowerState { power_state, responder } = self {
            Some((power_state, responder))
        } else {
            None
        }
    }

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

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

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

    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

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

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

impl DebugUtilsControlHandle {}

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for DependencyInjectionMarker {
    type Proxy = DependencyInjectionProxy;
    type RequestStream = DependencyInjectionRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = DependencyInjectionSynchronousProxy;

    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 fidl::endpoints::SynchronousProxy for DependencyInjectionSynchronousProxy {
    type Proxy = DependencyInjectionProxy;
    type Protocol = DependencyInjectionMarker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl 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::MonotonicInstant,
    ) -> 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::<DependencyInjectionSetMemoryPressureProviderRequest>(
            (provider,),
            0x5ef0be960d4b0f4c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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 fuchsia.gpu.magma/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 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::<DependencyInjectionSetMemoryPressureProviderRequest>(
            (provider,),
            0x5ef0be960d4b0f4c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(DependencyInjectionEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

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

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

/// A Stream of incoming requests for fuchsia.gpu.magma/DependencyInjection.
pub struct DependencyInjectionRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    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<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                0x5ef0be960d4b0f4c => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(DependencyInjectionSetMemoryPressureProviderRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DependencyInjectionSetMemoryPressureProviderRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = DependencyInjectionControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(DependencyInjectionRequest::SetMemoryPressureProvider {provider: req.provider,

                        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<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

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(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

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

impl 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;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = DeviceSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) Device";
}
pub type DeviceQueryResult = Result<DeviceQueryResponse, i32>;

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 fidl::endpoints::SynchronousProxy for DeviceSynchronousProxy {
    type Proxy = DeviceProxy;
    type Protocol = DeviceMarker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl 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::MonotonicInstant,
    ) -> 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::MonotonicInstant,
    ) -> Result<DeviceQueryResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<DeviceQueryRequest, fidl::encoding::ResultType<DeviceQueryResponse, i32>>(
                (query_id,),
                0x627d4c6093b078e7,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// 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::<DeviceConnect2Request>(
            (client_id, primary_channel, notification_channel),
            0x3a5b134714c67914,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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 fuchsia.gpu.magma/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 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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#query(&self, mut query_id: QueryId) -> Self::QueryResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceQueryResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<DeviceQueryResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x627d4c6093b078e7,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<DeviceQueryRequest, DeviceQueryResult>(
            (query_id,),
            0x627d4c6093b078e7,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    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::<DeviceConnect2Request>(
            (client_id, primary_channel, notification_channel),
            0x3a5b134714c67914,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(DeviceEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

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

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

/// A Stream of incoming requests for fuchsia.gpu.magma/Device.
pub struct DeviceRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    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<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x627d4c6093b078e7 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceQueryRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceQueryRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::Query {
                            query_id: req.query_id,

                            responder: DeviceQueryResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3a5b134714c67914 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceConnect2Request,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceConnect2Request>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::Connect2 {
                            client_id: req.client_id,
                            primary_channel: req.primary_channel,
                            notification_channel: req.notification_channel,

                            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<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

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(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

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

impl 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,
}

/// 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: Result<DeviceQueryResponse, i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

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

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

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

impl fidl::endpoints::ProtocolMarker for DiagnosticDeviceMarker {
    type Proxy = DiagnosticDeviceProxy;
    type RequestStream = DiagnosticDeviceRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = DiagnosticDeviceSynchronousProxy;

    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 fidl::endpoints::SynchronousProxy for DiagnosticDeviceSynchronousProxy {
    type Proxy = DiagnosticDeviceProxy;
    type Protocol = DiagnosticDeviceMarker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl 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::MonotonicInstant,
    ) -> 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::<DiagnosticDeviceDumpStateRequest>(
            (dump_type,),
            0x5420df493d4fa915,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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 fuchsia.gpu.magma/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 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::<DiagnosticDeviceDumpStateRequest>(
            (dump_type,),
            0x5420df493d4fa915,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(DiagnosticDeviceEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

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

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

/// A Stream of incoming requests for fuchsia.gpu.magma/DiagnosticDevice.
pub struct DiagnosticDeviceRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    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<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x5420df493d4fa915 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            DiagnosticDeviceDumpStateRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DiagnosticDeviceDumpStateRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DiagnosticDeviceControlHandle { inner: this.inner.clone() };
                        Ok(DiagnosticDeviceRequest::DumpState {
                            dump_type: req.dump_type,

                            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<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

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(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

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

impl 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;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = IcdLoaderDeviceSynchronousProxy;

    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 fidl::endpoints::SynchronousProxy for IcdLoaderDeviceSynchronousProxy {
    type Proxy = IcdLoaderDeviceProxy;
    type Protocol = IcdLoaderDeviceMarker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl 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::MonotonicInstant,
    ) -> 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::MonotonicInstant,
    ) -> Result<Vec<IcdInfo>, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, IcdLoaderDeviceGetIcdListResponse>(
                (),
                0x7673e76395008257,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.icd_list)
    }
}

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

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

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

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

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

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 fuchsia.gpu.magma/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 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>, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        IcdLoaderDeviceProxyInterface::r#get_icd_list(self)
    }
}

impl IcdLoaderDeviceProxyInterface for IcdLoaderDeviceProxy {
    type GetIcdListResponseFut =
        fidl::client::QueryResponseFut<Vec<IcdInfo>, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#get_icd_list(&self) -> Self::GetIcdListResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<IcdInfo>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                IcdLoaderDeviceGetIcdListResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7673e76395008257,
            >(_buf?)?;
            Ok(_response.icd_list)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<IcdInfo>>(
            (),
            0x7673e76395008257,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(IcdLoaderDeviceEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

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

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

/// A Stream of incoming requests for fuchsia.gpu.magma/IcdLoaderDevice.
pub struct IcdLoaderDeviceRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    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<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x7673e76395008257 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            IcdLoaderDeviceControlHandle { inner: this.inner.clone() };
                        Ok(IcdLoaderDeviceRequest::GetIcdList {
                            responder: IcdLoaderDeviceGetIcdListResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => 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<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

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(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

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

impl 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,
}

/// 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: &[IcdInfo]) -> Result<(), fidl::Error> {
        let _result = self.send_raw(icd_list);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

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

    fn send_raw(&self, mut icd_list: &[IcdInfo]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<IcdLoaderDeviceGetIcdListResponse>(
            (icd_list,),
            self.tx_id,
            0x7673e76395008257,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for NotificationMarker {
    type Proxy = NotificationProxy;
    type RequestStream = NotificationRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = NotificationSynchronousProxy;

    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 fidl::endpoints::SynchronousProxy for NotificationSynchronousProxy {
    type Proxy = NotificationProxy;
    type Protocol = NotificationMarker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl 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::MonotonicInstant,
    ) -> Result<NotificationEvent, fidl::Error> {
        NotificationEvent::decode(self.client.wait_for_event(deadline)?)
    }
}

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

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

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

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

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

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 fuchsia.gpu.magma/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 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<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

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>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(NotificationEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

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

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

/// A Stream of incoming requests for fuchsia.gpu.magma/Notification.
pub struct NotificationRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    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<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    _ => 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<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

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(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

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

impl 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;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = PerformanceCounterAccessSynchronousProxy;

    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 fidl::endpoints::SynchronousProxy for PerformanceCounterAccessSynchronousProxy {
    type Proxy = PerformanceCounterAccessProxy;
    type Protocol = PerformanceCounterAccessMarker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl 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::MonotonicInstant,
    ) -> 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::MonotonicInstant,
    ) -> Result<fidl::Event, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            PerformanceCounterAccessGetPerformanceCountTokenResponse,
        >(
            (),
            0x48410470c5f00f92,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.access_token)
    }
}

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

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

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

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

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

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 fuchsia.gpu.magma/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 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, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        PerformanceCounterAccessProxyInterface::r#get_performance_count_token(self)
    }
}

impl PerformanceCounterAccessProxyInterface for PerformanceCounterAccessProxy {
    type GetPerformanceCountTokenResponseFut =
        fidl::client::QueryResponseFut<fidl::Event, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#get_performance_count_token(&self) -> Self::GetPerformanceCountTokenResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<fidl::Event, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                PerformanceCounterAccessGetPerformanceCountTokenResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x48410470c5f00f92,
            >(_buf?)?;
            Ok(_response.access_token)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, fidl::Event>(
            (),
            0x48410470c5f00f92,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(PerformanceCounterAccessEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

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

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

/// A Stream of incoming requests for fuchsia.gpu.magma/PerformanceCounterAccess.
pub struct PerformanceCounterAccessRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    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<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                0x48410470c5f00f92 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = PerformanceCounterAccessControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(PerformanceCounterAccessRequest::GetPerformanceCountToken {
                        responder: PerformanceCounterAccessGetPerformanceCountTokenResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                _ => 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<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

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(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

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

impl 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,
}

/// 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 _result = self.send_raw(access_token);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

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

    fn send_raw(&self, mut access_token: fidl::Event) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<PerformanceCounterAccessGetPerformanceCountTokenResponse>(
            (access_token,),
            self.tx_id,
            0x48410470c5f00f92,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for PerformanceCounterEventsMarker {
    type Proxy = PerformanceCounterEventsProxy;
    type RequestStream = PerformanceCounterEventsRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = PerformanceCounterEventsSynchronousProxy;

    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 fidl::endpoints::SynchronousProxy for PerformanceCounterEventsSynchronousProxy {
    type Proxy = PerformanceCounterEventsProxy;
    type Protocol = PerformanceCounterEventsMarker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl 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::MonotonicInstant,
    ) -> Result<PerformanceCounterEventsEvent, fidl::Error> {
        PerformanceCounterEventsEvent::decode(self.client.wait_for_event(deadline)?)
    }
}

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

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

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

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

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

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 fuchsia.gpu.magma/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 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<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

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>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(PerformanceCounterEventsEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[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`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<PerformanceCounterEventsEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            0x3f134926720d44d7 => {
                let mut out = fidl::new_empty!(
                    PerformanceCounterEventsOnPerformanceCounterReadCompletedRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PerformanceCounterEventsOnPerformanceCounterReadCompletedRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((PerformanceCounterEventsEvent::OnPerformanceCounterReadCompleted {
                    payload: out,
                }))
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name:
                    <PerformanceCounterEventsMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.gpu.magma/PerformanceCounterEvents.
pub struct PerformanceCounterEventsRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    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<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                _ => 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<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

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(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

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

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

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

impl fidl::endpoints::ProtocolMarker for PowerElementProviderMarker {
    type Proxy = PowerElementProviderProxy;
    type RequestStream = PowerElementProviderRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = PowerElementProviderSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) PowerElementProvider";
}
pub type PowerElementProviderGetClockSpeedLevelResult =
    Result<PowerElementProviderGetClockSpeedLevelResponse, i32>;
pub type PowerElementProviderSetClockLimitResult =
    Result<PowerElementProviderSetClockLimitResponse, i32>;

pub trait PowerElementProviderProxyInterface: Send + Sync {
    type GetPowerGoalsResponseFut: std::future::Future<Output = Result<Vec<PowerGoal>, fidl::Error>>
        + Send;
    fn r#get_power_goals(&self) -> Self::GetPowerGoalsResponseFut;
    type GetClockSpeedLevelResponseFut: std::future::Future<
            Output = Result<PowerElementProviderGetClockSpeedLevelResult, fidl::Error>,
        > + Send;
    fn r#get_clock_speed_level(
        &self,
        payload: &PowerElementProviderGetClockSpeedLevelRequest,
    ) -> Self::GetClockSpeedLevelResponseFut;
    type SetClockLimitResponseFut: std::future::Future<Output = Result<PowerElementProviderSetClockLimitResult, fidl::Error>>
        + Send;
    fn r#set_clock_limit(
        &self,
        payload: &PowerElementProviderSetClockLimitRequest,
    ) -> Self::SetClockLimitResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct PowerElementProviderSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for PowerElementProviderSynchronousProxy {
    type Proxy = PowerElementProviderProxy;
    type Protocol = PowerElementProviderMarker;

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

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

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

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

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

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

    /// Retrieve a list of power goals that the hardware can attempt to achieve.
    pub fn r#get_power_goals(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Vec<PowerGoal>, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::FlexibleType<PowerElementProviderGetPowerGoalsResponse>,
        >(
            (),
            0x2ff49ddffb0e07c0,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<PowerElementProviderMarker>("get_power_goals")?;
        Ok(_response.goals)
    }

    /// Get a power level that represents the GPU clock being set to at least a target frequency.
    /// The power level may allow the GPU to idle or turn off, as long as the clock frequency
    /// remains the same.
    pub fn r#get_clock_speed_level(
        &self,
        mut payload: &PowerElementProviderGetClockSpeedLevelRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<PowerElementProviderGetClockSpeedLevelResult, fidl::Error> {
        let _response = self.client.send_query::<
            PowerElementProviderGetClockSpeedLevelRequest,
            fidl::encoding::FlexibleResultType<PowerElementProviderGetClockSpeedLevelResponse, i32>,
        >(
            payload,
            0x5315a9bc44a9c53c,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<PowerElementProviderMarker>("get_clock_speed_level")?;
        Ok(_response.map(|x| x))
    }

    /// Limit the clock to at most a specific frequency.
    pub fn r#set_clock_limit(
        &self,
        mut payload: &PowerElementProviderSetClockLimitRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<PowerElementProviderSetClockLimitResult, fidl::Error> {
        let _response = self.client.send_query::<
            PowerElementProviderSetClockLimitRequest,
            fidl::encoding::FlexibleResultType<PowerElementProviderSetClockLimitResponse, i32>,
        >(
            payload,
            0x614bf25c3a1571b4,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<PowerElementProviderMarker>("set_clock_limit")?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for PowerElementProviderProxy {
    type Protocol = PowerElementProviderMarker;

    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 PowerElementProviderProxy {
    /// Create a new Proxy for fuchsia.gpu.magma/PowerElementProvider.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <PowerElementProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

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

    /// Retrieve a list of power goals that the hardware can attempt to achieve.
    pub fn r#get_power_goals(
        &self,
    ) -> fidl::client::QueryResponseFut<Vec<PowerGoal>, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        PowerElementProviderProxyInterface::r#get_power_goals(self)
    }

    /// Get a power level that represents the GPU clock being set to at least a target frequency.
    /// The power level may allow the GPU to idle or turn off, as long as the clock frequency
    /// remains the same.
    pub fn r#get_clock_speed_level(
        &self,
        mut payload: &PowerElementProviderGetClockSpeedLevelRequest,
    ) -> fidl::client::QueryResponseFut<
        PowerElementProviderGetClockSpeedLevelResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        PowerElementProviderProxyInterface::r#get_clock_speed_level(self, payload)
    }

    /// Limit the clock to at most a specific frequency.
    pub fn r#set_clock_limit(
        &self,
        mut payload: &PowerElementProviderSetClockLimitRequest,
    ) -> fidl::client::QueryResponseFut<
        PowerElementProviderSetClockLimitResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        PowerElementProviderProxyInterface::r#set_clock_limit(self, payload)
    }
}

impl PowerElementProviderProxyInterface for PowerElementProviderProxy {
    type GetPowerGoalsResponseFut = fidl::client::QueryResponseFut<
        Vec<PowerGoal>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_power_goals(&self) -> Self::GetPowerGoalsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<PowerGoal>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<PowerElementProviderGetPowerGoalsResponse>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2ff49ddffb0e07c0,
            >(_buf?)?
            .into_result::<PowerElementProviderMarker>("get_power_goals")?;
            Ok(_response.goals)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<PowerGoal>>(
            (),
            0x2ff49ddffb0e07c0,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type GetClockSpeedLevelResponseFut = fidl::client::QueryResponseFut<
        PowerElementProviderGetClockSpeedLevelResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_clock_speed_level(
        &self,
        mut payload: &PowerElementProviderGetClockSpeedLevelRequest,
    ) -> Self::GetClockSpeedLevelResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<PowerElementProviderGetClockSpeedLevelResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<
                    PowerElementProviderGetClockSpeedLevelResponse,
                    i32,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5315a9bc44a9c53c,
            >(_buf?)?
            .into_result::<PowerElementProviderMarker>("get_clock_speed_level")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            PowerElementProviderGetClockSpeedLevelRequest,
            PowerElementProviderGetClockSpeedLevelResult,
        >(
            payload,
            0x5315a9bc44a9c53c,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type SetClockLimitResponseFut = fidl::client::QueryResponseFut<
        PowerElementProviderSetClockLimitResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_clock_limit(
        &self,
        mut payload: &PowerElementProviderSetClockLimitRequest,
    ) -> Self::SetClockLimitResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<PowerElementProviderSetClockLimitResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<PowerElementProviderSetClockLimitResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x614bf25c3a1571b4,
            >(_buf?)?
            .into_result::<PowerElementProviderMarker>("set_clock_limit")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            PowerElementProviderSetClockLimitRequest,
            PowerElementProviderSetClockLimitResult,
        >(
            payload,
            0x614bf25c3a1571b4,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }
}

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

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.gpu.magma/PowerElementProvider.
pub struct PowerElementProviderRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for PowerElementProviderRequestStream {
    type Protocol = PowerElementProviderMarker;
    type ControlHandle = PowerElementProviderControlHandle;

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

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

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

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

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled PowerElementProviderRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

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

                std::task::Poll::Ready(Some(match header.ordinal {
                0x2ff49ddffb0e07c0 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = PowerElementProviderControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(PowerElementProviderRequest::GetPowerGoals {
                        responder: PowerElementProviderGetPowerGoalsResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x5315a9bc44a9c53c => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(PowerElementProviderGetClockSpeedLevelRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PowerElementProviderGetClockSpeedLevelRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = PowerElementProviderControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(PowerElementProviderRequest::GetClockSpeedLevel {payload: req,
                        responder: PowerElementProviderGetClockSpeedLevelResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x614bf25c3a1571b4 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(PowerElementProviderSetClockLimitRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PowerElementProviderSetClockLimitRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = PowerElementProviderControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(PowerElementProviderRequest::SetClockLimit {payload: req,
                        responder: PowerElementProviderSetClockLimitResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                _ if header.tx_id == 0 && header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                    Ok(PowerElementProviderRequest::_UnknownMethod {
                        ordinal: header.ordinal,
                        control_handle: PowerElementProviderControlHandle { inner: this.inner.clone() },
                        method_type: fidl::MethodType::OneWay,
                    })
                }
                _ if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                    this.inner.send_framework_err(
                        fidl::encoding::FrameworkErr::UnknownMethod,
                        header.tx_id,
                        header.ordinal,
                        header.dynamic_flags(),
                        (bytes, handles),
                    )?;
                    Ok(PowerElementProviderRequest::_UnknownMethod {
                        ordinal: header.ordinal,
                        control_handle: PowerElementProviderControlHandle { inner: this.inner.clone() },
                        method_type: fidl::MethodType::TwoWay,
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <PowerElementProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// This protocol is used to retrieve information on the power levels that this driver provides.
#[derive(Debug)]
pub enum PowerElementProviderRequest {
    /// Retrieve a list of power goals that the hardware can attempt to achieve.
    GetPowerGoals { responder: PowerElementProviderGetPowerGoalsResponder },
    /// Get a power level that represents the GPU clock being set to at least a target frequency.
    /// The power level may allow the GPU to idle or turn off, as long as the clock frequency
    /// remains the same.
    GetClockSpeedLevel {
        payload: PowerElementProviderGetClockSpeedLevelRequest,
        responder: PowerElementProviderGetClockSpeedLevelResponder,
    },
    /// Limit the clock to at most a specific frequency.
    SetClockLimit {
        payload: PowerElementProviderSetClockLimitRequest,
        responder: PowerElementProviderSetClockLimitResponder,
    },
    /// An interaction was received which does not match any known method.
    #[non_exhaustive]
    _UnknownMethod {
        /// Ordinal of the method that was called.
        ordinal: u64,
        control_handle: PowerElementProviderControlHandle,
        method_type: fidl::MethodType,
    },
}

impl PowerElementProviderRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_power_goals(self) -> Option<(PowerElementProviderGetPowerGoalsResponder)> {
        if let PowerElementProviderRequest::GetPowerGoals { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_clock_speed_level(
        self,
    ) -> Option<(
        PowerElementProviderGetClockSpeedLevelRequest,
        PowerElementProviderGetClockSpeedLevelResponder,
    )> {
        if let PowerElementProviderRequest::GetClockSpeedLevel { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_clock_limit(
        self,
    ) -> Option<(
        PowerElementProviderSetClockLimitRequest,
        PowerElementProviderSetClockLimitResponder,
    )> {
        if let PowerElementProviderRequest::SetClockLimit { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            PowerElementProviderRequest::GetPowerGoals { .. } => "get_power_goals",
            PowerElementProviderRequest::GetClockSpeedLevel { .. } => "get_clock_speed_level",
            PowerElementProviderRequest::SetClockLimit { .. } => "set_clock_limit",
            PowerElementProviderRequest::_UnknownMethod {
                method_type: fidl::MethodType::OneWay,
                ..
            } => "unknown one-way method",
            PowerElementProviderRequest::_UnknownMethod {
                method_type: fidl::MethodType::TwoWay,
                ..
            } => "unknown two-way method",
        }
    }
}

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

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

    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

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

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

impl PowerElementProviderControlHandle {}

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

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

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

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

    fn send_raw(&self, mut goals: Vec<PowerGoal>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleType<
            PowerElementProviderGetPowerGoalsResponse,
        >>(
            fidl::encoding::Flexible::new((goals.as_mut(),)),
            self.tx_id,
            0x2ff49ddffb0e07c0,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

    fn send_raw(
        &self,
        mut result: Result<PowerElementProviderGetClockSpeedLevelResponse, i32>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
            PowerElementProviderGetClockSpeedLevelResponse,
            i32,
        >>(
            fidl::encoding::FlexibleResult::new(result.as_mut().map_err(|e| *e)),
            self.tx_id,
            0x5315a9bc44a9c53c,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

    fn send_raw(
        &self,
        mut result: Result<PowerElementProviderSetClockLimitResponse, i32>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
            PowerElementProviderSetClockLimitResponse,
            i32,
        >>(
            fidl::encoding::FlexibleResult::new(result.as_mut().map_err(|e| *e)),
            self.tx_id,
            0x614bf25c3a1571b4,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for PrimaryMarker {
    type Proxy = PrimaryProxy;
    type RequestStream = PrimaryRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = PrimarySynchronousProxy;

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

pub trait PrimaryProxyInterface: Send + Sync {
    fn r#import_object(&self, payload: PrimaryImportObjectRequest) -> 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#create_context2(&self, context_id: u32, priority: Priority) -> Result<(), fidl::Error>;
    fn r#destroy_context(&self, context_id: u32) -> Result<(), fidl::Error>;
    fn r#execute_command(
        &self,
        context_id: u32,
        resources: &[BufferRange],
        command_buffers: &[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>;
    fn r#execute_inline_commands(
        &self,
        context_id: u32,
        commands: &[InlineCommand],
    ) -> 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: &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: &[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 fidl::endpoints::SynchronousProxy for PrimarySynchronousProxy {
    type Proxy = PrimaryProxy;
    type Protocol = PrimaryMarker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl 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::MonotonicInstant,
    ) -> 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_object(
        &self,
        mut payload: PrimaryImportObjectRequest,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PrimaryImportObjectRequest>(
            &mut payload,
            0x5f5a247abb1d9354,
            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::<PrimaryReleaseObjectRequest>(
            (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.
    /// DEPRECATED: Please use CreateContext2.
    /// TODO(https://fxbug.dev/413030654): Fully deprecate this API.
    pub fn r#create_context(&self, mut context_id: u32) -> Result<(), fidl::Error> {
        self.client.send::<PrimaryCreateContextRequest>(
            (context_id,),
            0x5a9a91c8b88b5da4,
            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_context2(
        &self,
        mut context_id: u32,
        mut priority: Priority,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PrimaryCreateContext2Request>(
            (context_id, priority),
            0x5f7e3a5137e758f6,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Destroys context `context_id`.
    pub fn r#destroy_context(&self, mut context_id: u32) -> Result<(), fidl::Error> {
        self.client.send::<PrimaryDestroyContextRequest>(
            (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: &[BufferRange],
        mut command_buffers: &[CommandBuffer],
        mut wait_semaphores: &[u64],
        mut signal_semaphores: &[u64],
        mut flags: CommandBufferFlags,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PrimaryExecuteCommandRequest>(
            (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::<PrimaryExecuteImmediateCommandsRequest>(
            (context_id, command_data, semaphores),
            0x3d7e0dcdbfd4b61f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Submits a series of commands for execution on the hardware without using a command buffer.
    /// The number of commands sent should be calculated so that the total message size is less than
    /// MAX_INLINE_COMMANDS_DATA_SIZE.
    pub fn r#execute_inline_commands(
        &self,
        mut context_id: u32,
        mut commands: &[InlineCommand],
    ) -> Result<(), fidl::Error> {
        self.client.send::<PrimaryExecuteInlineCommandsRequest>(
            (context_id, commands),
            0x766d5c86f35468a6,
            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::MonotonicInstant) -> Result<(), fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::EmptyPayload>(
                (),
                0x54ccb5572d886039,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    /// 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::<PrimaryMapBufferRequest>(
            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::<PrimaryUnmapBufferRequest>(
            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: &BufferRange,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PrimaryBufferRangeOp2Request>(
            (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::<fidl::encoding::EmptyPayload>(
            (),
            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::<PrimaryEnablePerformanceCounterAccessRequest>(
            (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::MonotonicInstant,
    ) -> Result<bool, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            PrimaryIsPerformanceCounterAccessAllowedResponse,
        >(
            (),
            0x1933b70c06cc5702,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.enabled)
    }

    /// 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::<PrimaryEnablePerformanceCountersRequest>(
            (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::<PrimaryCreatePerformanceCounterBufferPoolRequest>(
            (pool_id, 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::<PrimaryReleasePerformanceCounterBufferPoolRequest>(
            (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: &[BufferRange],
    ) -> Result<(), fidl::Error> {
        self.client.send::<PrimaryAddPerformanceCounterBufferOffsetsToPoolRequest>(
            (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::<PrimaryRemovePerformanceCounterBufferFromPoolRequest>(
            (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::<PrimaryDumpPerformanceCountersRequest>(
            (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::<PrimaryClearPerformanceCountersRequest>(
            (counters,),
            0x236831822eff741a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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 fuchsia.gpu.magma/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 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_object(
        &self,
        mut payload: PrimaryImportObjectRequest,
    ) -> Result<(), fidl::Error> {
        PrimaryProxyInterface::r#import_object(self, payload)
    }

    /// 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.
    /// DEPRECATED: Please use CreateContext2.
    /// TODO(https://fxbug.dev/413030654): Fully deprecate this API.
    pub fn r#create_context(&self, mut context_id: u32) -> Result<(), fidl::Error> {
        PrimaryProxyInterface::r#create_context(self, context_id)
    }

    /// Creates context `context_id` for use in command execution.  A context may be associated
    /// with hardware state.
    pub fn r#create_context2(
        &self,
        mut context_id: u32,
        mut priority: Priority,
    ) -> Result<(), fidl::Error> {
        PrimaryProxyInterface::r#create_context2(self, context_id, priority)
    }

    /// 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: &[BufferRange],
        mut command_buffers: &[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,
        )
    }

    /// Submits a series of commands for execution on the hardware without using a command buffer.
    /// The number of commands sent should be calculated so that the total message size is less than
    /// MAX_INLINE_COMMANDS_DATA_SIZE.
    pub fn r#execute_inline_commands(
        &self,
        mut context_id: u32,
        mut commands: &[InlineCommand],
    ) -> Result<(), fidl::Error> {
        PrimaryProxyInterface::r#execute_inline_commands(self, context_id, commands)
    }

    /// 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<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        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: &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, fidl::encoding::DefaultFuchsiaResourceDialect> {
        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: &[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_object(&self, mut payload: PrimaryImportObjectRequest) -> Result<(), fidl::Error> {
        self.client.send::<PrimaryImportObjectRequest>(
            &mut payload,
            0x5f5a247abb1d9354,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#release_object(
        &self,
        mut object_id: u64,
        mut object_type: ObjectType,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PrimaryReleaseObjectRequest>(
            (object_id, object_type),
            0x4a65d5885da5e88f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#create_context(&self, mut context_id: u32) -> Result<(), fidl::Error> {
        self.client.send::<PrimaryCreateContextRequest>(
            (context_id,),
            0x5a9a91c8b88b5da4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#create_context2(
        &self,
        mut context_id: u32,
        mut priority: Priority,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PrimaryCreateContext2Request>(
            (context_id, priority),
            0x5f7e3a5137e758f6,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#destroy_context(&self, mut context_id: u32) -> Result<(), fidl::Error> {
        self.client.send::<PrimaryDestroyContextRequest>(
            (context_id,),
            0x26b626e6be162ef0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#execute_command(
        &self,
        mut context_id: u32,
        mut resources: &[BufferRange],
        mut command_buffers: &[CommandBuffer],
        mut wait_semaphores: &[u64],
        mut signal_semaphores: &[u64],
        mut flags: CommandBufferFlags,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PrimaryExecuteCommandRequest>(
            (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::<PrimaryExecuteImmediateCommandsRequest>(
            (context_id, command_data, semaphores),
            0x3d7e0dcdbfd4b61f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#execute_inline_commands(
        &self,
        mut context_id: u32,
        mut commands: &[InlineCommand],
    ) -> Result<(), fidl::Error> {
        self.client.send::<PrimaryExecuteInlineCommandsRequest>(
            (context_id, commands),
            0x766d5c86f35468a6,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

    fn r#map_buffer(&self, mut payload: &PrimaryMapBufferRequest) -> Result<(), fidl::Error> {
        self.client.send::<PrimaryMapBufferRequest>(
            payload,
            0x56baa5d2092c8e33,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#unmap_buffer(&self, mut payload: &PrimaryUnmapBufferRequest) -> Result<(), fidl::Error> {
        self.client.send::<PrimaryUnmapBufferRequest>(
            payload,
            0x305188ebd8bcd95c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#buffer_range_op2(
        &self,
        mut op: BufferOp,
        mut range: &BufferRange,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PrimaryBufferRangeOp2Request>(
            (op, range),
            0x4175c8dfef355396,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

    fn r#enable_performance_counter_access(
        &self,
        mut access_token: fidl::Event,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PrimaryEnablePerformanceCounterAccessRequest>(
            (access_token,),
            0x51b369ac16588831,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

    fn r#enable_performance_counters(&self, mut counters: &[u64]) -> Result<(), fidl::Error> {
        self.client.send::<PrimaryEnablePerformanceCountersRequest>(
            (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::<PrimaryCreatePerformanceCounterBufferPoolRequest>(
            (pool_id, 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::<PrimaryReleasePerformanceCounterBufferPoolRequest>(
            (pool_id,),
            0x18374c4b3ef0b4da,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#add_performance_counter_buffer_offsets_to_pool(
        &self,
        mut pool_id: u64,
        mut offsets: &[BufferRange],
    ) -> Result<(), fidl::Error> {
        self.client.send::<PrimaryAddPerformanceCounterBufferOffsetsToPoolRequest>(
            (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::<PrimaryRemovePerformanceCounterBufferFromPoolRequest>(
            (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::<PrimaryDumpPerformanceCountersRequest>(
            (pool_id, trigger_id),
            0x250b29340be28807,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#clear_performance_counters(&self, mut counters: &[u64]) -> Result<(), fidl::Error> {
        self.client.send::<PrimaryClearPerformanceCountersRequest>(
            (counters,),
            0x236831822eff741a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(PrimaryEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[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`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<PrimaryEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            0x5e8dd0b0b753ac43 => {
                let mut out = fidl::new_empty!(
                    PrimaryOnNotifyMessagesConsumedRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PrimaryOnNotifyMessagesConsumedRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((PrimaryEvent::OnNotifyMessagesConsumed { count: out.count }))
            }
            0x50524b7a3503aba6 => {
                let mut out = fidl::new_empty!(
                    PrimaryOnNotifyMemoryImportedRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PrimaryOnNotifyMemoryImportedRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((PrimaryEvent::OnNotifyMemoryImported { bytes: out.bytes }))
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <PrimaryMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.gpu.magma/Primary.
pub struct PrimaryRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    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<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x5f5a247abb1d9354 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PrimaryImportObjectRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PrimaryImportObjectRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PrimaryControlHandle { inner: this.inner.clone() };
                        Ok(PrimaryRequest::ImportObject { payload: req, control_handle })
                    }
                    0x4a65d5885da5e88f => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PrimaryReleaseObjectRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PrimaryReleaseObjectRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PrimaryControlHandle { inner: this.inner.clone() };
                        Ok(PrimaryRequest::ReleaseObject {
                            object_id: req.object_id,
                            object_type: req.object_type,

                            control_handle,
                        })
                    }
                    0x5a9a91c8b88b5da4 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PrimaryCreateContextRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PrimaryCreateContextRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PrimaryControlHandle { inner: this.inner.clone() };
                        Ok(PrimaryRequest::CreateContext {
                            context_id: req.context_id,

                            control_handle,
                        })
                    }
                    0x5f7e3a5137e758f6 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PrimaryCreateContext2Request,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PrimaryCreateContext2Request>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PrimaryControlHandle { inner: this.inner.clone() };
                        Ok(PrimaryRequest::CreateContext2 {
                            context_id: req.context_id,
                            priority: req.priority,

                            control_handle,
                        })
                    }
                    0x26b626e6be162ef0 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PrimaryDestroyContextRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PrimaryDestroyContextRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PrimaryControlHandle { inner: this.inner.clone() };
                        Ok(PrimaryRequest::DestroyContext {
                            context_id: req.context_id,

                            control_handle,
                        })
                    }
                    0xf2799643aadb0db => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PrimaryExecuteCommandRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PrimaryExecuteCommandRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PrimaryControlHandle { inner: this.inner.clone() };
                        Ok(PrimaryRequest::ExecuteCommand {
                            context_id: req.context_id,
                            resources: req.resources,
                            command_buffers: req.command_buffers,
                            wait_semaphores: req.wait_semaphores,
                            signal_semaphores: req.signal_semaphores,
                            flags: req.flags,

                            control_handle,
                        })
                    }
                    0x3d7e0dcdbfd4b61f => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PrimaryExecuteImmediateCommandsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PrimaryExecuteImmediateCommandsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PrimaryControlHandle { inner: this.inner.clone() };
                        Ok(PrimaryRequest::ExecuteImmediateCommands {
                            context_id: req.context_id,
                            command_data: req.command_data,
                            semaphores: req.semaphores,

                            control_handle,
                        })
                    }
                    0x766d5c86f35468a6 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PrimaryExecuteInlineCommandsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PrimaryExecuteInlineCommandsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PrimaryControlHandle { inner: this.inner.clone() };
                        Ok(PrimaryRequest::ExecuteInlineCommands {
                            context_id: req.context_id,
                            commands: req.commands,

                            control_handle,
                        })
                    }
                    0x54ccb5572d886039 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PrimaryControlHandle { inner: this.inner.clone() };
                        Ok(PrimaryRequest::Flush {
                            responder: PrimaryFlushResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x56baa5d2092c8e33 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PrimaryMapBufferRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PrimaryMapBufferRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PrimaryControlHandle { inner: this.inner.clone() };
                        Ok(PrimaryRequest::MapBuffer { payload: req, control_handle })
                    }
                    0x305188ebd8bcd95c => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PrimaryUnmapBufferRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PrimaryUnmapBufferRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PrimaryControlHandle { inner: this.inner.clone() };
                        Ok(PrimaryRequest::UnmapBuffer { payload: req, control_handle })
                    }
                    0x4175c8dfef355396 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PrimaryBufferRangeOp2Request,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PrimaryBufferRangeOp2Request>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PrimaryControlHandle { inner: this.inner.clone() };
                        Ok(PrimaryRequest::BufferRangeOp2 {
                            op: req.op,
                            range: req.range,

                            control_handle,
                        })
                    }
                    0x8b5e68f3ee0b22e => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PrimaryControlHandle { inner: this.inner.clone() };
                        Ok(PrimaryRequest::EnableFlowControl { control_handle })
                    }
                    0x51b369ac16588831 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PrimaryEnablePerformanceCounterAccessRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PrimaryEnablePerformanceCounterAccessRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PrimaryControlHandle { inner: this.inner.clone() };
                        Ok(PrimaryRequest::EnablePerformanceCounterAccess {
                            access_token: req.access_token,

                            control_handle,
                        })
                    }
                    0x1933b70c06cc5702 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PrimaryControlHandle { inner: this.inner.clone() };
                        Ok(PrimaryRequest::IsPerformanceCounterAccessAllowed {
                            responder: PrimaryIsPerformanceCounterAccessAllowedResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x52c4db74b601aaa7 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PrimaryEnablePerformanceCountersRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PrimaryEnablePerformanceCountersRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PrimaryControlHandle { inner: this.inner.clone() };
                        Ok(PrimaryRequest::EnablePerformanceCounters {
                            counters: req.counters,

                            control_handle,
                        })
                    }
                    0x48ccf6519bbbc638 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PrimaryCreatePerformanceCounterBufferPoolRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PrimaryCreatePerformanceCounterBufferPoolRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PrimaryControlHandle { inner: this.inner.clone() };
                        Ok(PrimaryRequest::CreatePerformanceCounterBufferPool {
                            pool_id: req.pool_id,
                            event_channel: req.event_channel,

                            control_handle,
                        })
                    }
                    0x18374c4b3ef0b4da => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PrimaryReleasePerformanceCounterBufferPoolRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PrimaryReleasePerformanceCounterBufferPoolRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PrimaryControlHandle { inner: this.inner.clone() };
                        Ok(PrimaryRequest::ReleasePerformanceCounterBufferPool {
                            pool_id: req.pool_id,

                            control_handle,
                        })
                    }
                    0x1f7889571111386b => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PrimaryAddPerformanceCounterBufferOffsetsToPoolRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PrimaryAddPerformanceCounterBufferOffsetsToPoolRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PrimaryControlHandle { inner: this.inner.clone() };
                        Ok(PrimaryRequest::AddPerformanceCounterBufferOffsetsToPool {
                            pool_id: req.pool_id,
                            offsets: req.offsets,

                            control_handle,
                        })
                    }
                    0xbf1275f5a36258e => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PrimaryRemovePerformanceCounterBufferFromPoolRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PrimaryRemovePerformanceCounterBufferFromPoolRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PrimaryControlHandle { inner: this.inner.clone() };
                        Ok(PrimaryRequest::RemovePerformanceCounterBufferFromPool {
                            pool_id: req.pool_id,
                            buffer_id: req.buffer_id,

                            control_handle,
                        })
                    }
                    0x250b29340be28807 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PrimaryDumpPerformanceCountersRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PrimaryDumpPerformanceCountersRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PrimaryControlHandle { inner: this.inner.clone() };
                        Ok(PrimaryRequest::DumpPerformanceCounters {
                            pool_id: req.pool_id,
                            trigger_id: req.trigger_id,

                            control_handle,
                        })
                    }
                    0x236831822eff741a => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PrimaryClearPerformanceCountersRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PrimaryClearPerformanceCountersRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PrimaryControlHandle { inner: this.inner.clone() };
                        Ok(PrimaryRequest::ClearPerformanceCounters {
                            counters: req.counters,

                            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.
    ImportObject { payload: PrimaryImportObjectRequest, 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.
    /// DEPRECATED: Please use CreateContext2.
    /// TODO(https://fxbug.dev/413030654): Fully deprecate this API.
    CreateContext { context_id: u32, control_handle: PrimaryControlHandle },
    /// Creates context `context_id` for use in command execution.  A context may be associated
    /// with hardware state.
    CreateContext2 { context_id: u32, priority: Priority, 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,
    },
    /// Submits a series of commands for execution on the hardware without using a command buffer.
    /// The number of commands sent should be calculated so that the total message size is less than
    /// MAX_INLINE_COMMANDS_DATA_SIZE.
    ExecuteInlineCommands {
        context_id: u32,
        commands: Vec<InlineCommand>,
        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_object(self) -> Option<(PrimaryImportObjectRequest, PrimaryControlHandle)> {
        if let PrimaryRequest::ImportObject { payload, control_handle } = self {
            Some((payload, 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_create_context2(self) -> Option<(u32, Priority, PrimaryControlHandle)> {
        if let PrimaryRequest::CreateContext2 { context_id, priority, control_handle } = self {
            Some((context_id, priority, 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_execute_inline_commands(
        self,
    ) -> Option<(u32, Vec<InlineCommand>, PrimaryControlHandle)> {
        if let PrimaryRequest::ExecuteInlineCommands { context_id, commands, control_handle } = self
        {
            Some((context_id, commands, 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::ImportObject { .. } => "import_object",
            PrimaryRequest::ReleaseObject { .. } => "release_object",
            PrimaryRequest::CreateContext { .. } => "create_context",
            PrimaryRequest::CreateContext2 { .. } => "create_context2",
            PrimaryRequest::DestroyContext { .. } => "destroy_context",
            PrimaryRequest::ExecuteCommand { .. } => "execute_command",
            PrimaryRequest::ExecuteImmediateCommands { .. } => "execute_immediate_commands",
            PrimaryRequest::ExecuteInlineCommands { .. } => "execute_inline_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<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

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(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

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

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

    pub fn send_on_notify_memory_imported(&self, mut bytes: u64) -> Result<(), fidl::Error> {
        self.inner.send::<PrimaryOnNotifyMemoryImportedRequest>(
            (bytes,),
            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,
}

/// 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 _result = self.send_raw();
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

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

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

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

/// 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 _result = self.send_raw(enabled);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

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

    fn send_raw(&self, mut enabled: bool) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<PrimaryIsPerformanceCounterAccessAllowedResponse>(
            (enabled,),
            self.tx_id,
            0x1933b70c06cc5702,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for TestDeviceMarker {
    type Proxy = TestDeviceProxy;
    type RequestStream = TestDeviceRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = TestDeviceSynchronousProxy;

    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 fidl::endpoints::SynchronousProxy for TestDeviceSynchronousProxy {
    type Proxy = TestDeviceProxy;
    type Protocol = TestDeviceMarker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl 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::MonotonicInstant,
    ) -> 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::MonotonicInstant,
    ) -> Result<DeviceQueryResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<DeviceQueryRequest, fidl::encoding::ResultType<DeviceQueryResponse, i32>>(
                (query_id,),
                0x627d4c6093b078e7,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// 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::<DeviceConnect2Request>(
            (client_id, primary_channel, 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::<DiagnosticDeviceDumpStateRequest>(
            (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::MonotonicInstant,
    ) -> Result<Vec<IcdInfo>, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, IcdLoaderDeviceGetIcdListResponse>(
                (),
                0x7673e76395008257,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.icd_list)
    }

    pub fn r#get_unit_test_status(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<i32, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, TestDeviceGetUnitTestStatusResponse>(
                (),
                0x3ebcd9c409c248f1,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.status)
    }
}

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

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

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

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

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

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 fuchsia.gpu.magma/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 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,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        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>, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        TestDeviceProxyInterface::r#get_icd_list(self)
    }

    pub fn r#get_unit_test_status(
        &self,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        TestDeviceProxyInterface::r#get_unit_test_status(self)
    }
}

impl TestDeviceProxyInterface for TestDeviceProxy {
    type QueryResponseFut = fidl::client::QueryResponseFut<
        DeviceQueryResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#query(&self, mut query_id: QueryId) -> Self::QueryResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceQueryResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<DeviceQueryResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x627d4c6093b078e7,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<DeviceQueryRequest, DeviceQueryResult>(
            (query_id,),
            0x627d4c6093b078e7,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    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::<DeviceConnect2Request>(
            (client_id, primary_channel, notification_channel),
            0x3a5b134714c67914,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

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

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

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

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>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(TestDeviceEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

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

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

/// A Stream of incoming requests for fuchsia.gpu.magma/TestDevice.
pub struct TestDeviceRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    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<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x627d4c6093b078e7 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceQueryRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceQueryRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = TestDeviceControlHandle { inner: this.inner.clone() };
                        Ok(TestDeviceRequest::Query {
                            query_id: req.query_id,

                            responder: TestDeviceQueryResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3a5b134714c67914 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceConnect2Request,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceConnect2Request>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = TestDeviceControlHandle { inner: this.inner.clone() };
                        Ok(TestDeviceRequest::Connect2 {
                            client_id: req.client_id,
                            primary_channel: req.primary_channel,
                            notification_channel: req.notification_channel,

                            control_handle,
                        })
                    }
                    0x5420df493d4fa915 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            DiagnosticDeviceDumpStateRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DiagnosticDeviceDumpStateRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = TestDeviceControlHandle { inner: this.inner.clone() };
                        Ok(TestDeviceRequest::DumpState {
                            dump_type: req.dump_type,

                            control_handle,
                        })
                    }
                    0x7673e76395008257 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = TestDeviceControlHandle { inner: this.inner.clone() };
                        Ok(TestDeviceRequest::GetIcdList {
                            responder: TestDeviceGetIcdListResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3ebcd9c409c248f1 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = TestDeviceControlHandle { inner: this.inner.clone() };
                        Ok(TestDeviceRequest::GetUnitTestStatus {
                            responder: TestDeviceGetUnitTestStatusResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => 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.
/// DEPRECATED: Please use TestDevice2.
#[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<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

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(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

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

impl 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,
}

/// 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: Result<DeviceQueryResponse, i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

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

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

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

/// 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: &[IcdInfo]) -> Result<(), fidl::Error> {
        let _result = self.send_raw(icd_list);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

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

    fn send_raw(&self, mut icd_list: &[IcdInfo]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<IcdLoaderDeviceGetIcdListResponse>(
            (icd_list,),
            self.tx_id,
            0x7673e76395008257,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// 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 _result = self.send_raw(status);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

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

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

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

impl fidl::endpoints::ProtocolMarker for TestDevice2Marker {
    type Proxy = TestDevice2Proxy;
    type RequestStream = TestDevice2RequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = TestDevice2SynchronousProxy;

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

pub trait TestDevice2ProxyInterface: Send + Sync {
    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 TestDevice2SynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for TestDevice2SynchronousProxy {
    type Proxy = TestDevice2Proxy;
    type Protocol = TestDevice2Marker;

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

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

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

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

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

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

    pub fn r#get_unit_test_status(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<i32, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, TestDevice2GetUnitTestStatusResponse>(
                (),
                0x5be45b0f097813b2,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.status)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for TestDevice2Proxy {
    type Protocol = TestDevice2Marker;

    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 TestDevice2Proxy {
    /// Create a new Proxy for fuchsia.gpu.magma/TestDevice2.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <TestDevice2Marker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

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

    pub fn r#get_unit_test_status(
        &self,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        TestDevice2ProxyInterface::r#get_unit_test_status(self)
    }
}

impl TestDevice2ProxyInterface for TestDevice2Proxy {
    type GetUnitTestStatusResponseFut =
        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#get_unit_test_status(&self) -> Self::GetUnitTestStatusResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                TestDevice2GetUnitTestStatusResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5be45b0f097813b2,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, i32>(
            (),
            0x5be45b0f097813b2,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.gpu.magma/TestDevice2.
pub struct TestDevice2RequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for TestDevice2RequestStream {
    type Protocol = TestDevice2Marker;
    type ControlHandle = TestDevice2ControlHandle;

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

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

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

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

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled TestDevice2RequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

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

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

/// Additional methods for reporting tests run in the MSD.
#[derive(Debug)]
pub enum TestDevice2Request {
    GetUnitTestStatus { responder: TestDevice2GetUnitTestStatusResponder },
}

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

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

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

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

    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

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

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

impl TestDevice2ControlHandle {}

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

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

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

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

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

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

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceMarker for DependencyInjectionServiceMarker {
    type Proxy = DependencyInjectionServiceProxy;
    type Request = DependencyInjectionServiceRequest;
    const SERVICE_NAME: &'static str = "fuchsia.gpu.magma.DependencyInjectionService";
}

/// A request for one of the member protocols of DependencyInjectionService.
///
#[cfg(target_os = "fuchsia")]
pub enum DependencyInjectionServiceRequest {
    Device(DependencyInjectionRequestStream),
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceRequest for DependencyInjectionServiceRequest {
    type Service = DependencyInjectionServiceMarker;

    fn dispatch(name: &str, _channel: fidl::AsyncChannel) -> Self {
        match name {
            "device" => Self::Device(
                <DependencyInjectionRequestStream as fidl::endpoints::RequestStream>::from_channel(
                    _channel,
                ),
            ),
            _ => panic!("no such member protocol name for service DependencyInjectionService"),
        }
    }

    fn member_names() -> &'static [&'static str] {
        &["device"]
    }
}
#[cfg(target_os = "fuchsia")]
pub struct DependencyInjectionServiceProxy(
    #[allow(dead_code)] Box<dyn fidl::endpoints::MemberOpener>,
);

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceProxy for DependencyInjectionServiceProxy {
    type Service = DependencyInjectionServiceMarker;

    fn from_member_opener(opener: Box<dyn fidl::endpoints::MemberOpener>) -> Self {
        Self(opener)
    }
}

#[cfg(target_os = "fuchsia")]
impl DependencyInjectionServiceProxy {
    pub fn connect_to_device(&self) -> Result<DependencyInjectionProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_proxy::<DependencyInjectionMarker>();
        self.connect_channel_to_device(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_device`, but returns a sync proxy.
    /// See [`Self::connect_to_device`] for more details.
    pub fn connect_to_device_sync(
        &self,
    ) -> Result<DependencyInjectionSynchronousProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_sync_proxy::<DependencyInjectionMarker>();
        self.connect_channel_to_device(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_device`, but accepts a server end.
    /// See [`Self::connect_to_device`] for more details.
    pub fn connect_channel_to_device(
        &self,
        server_end: fidl::endpoints::ServerEnd<DependencyInjectionMarker>,
    ) -> Result<(), fidl::Error> {
        self.0.open_member("device", server_end.into_channel())
    }

    pub fn instance_name(&self) -> &str {
        self.0.instance_name()
    }
}

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

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceMarker for PerformanceCounterServiceMarker {
    type Proxy = PerformanceCounterServiceProxy;
    type Request = PerformanceCounterServiceRequest;
    const SERVICE_NAME: &'static str = "fuchsia.gpu.magma.PerformanceCounterService";
}

/// A request for one of the member protocols of PerformanceCounterService.
///
#[cfg(target_os = "fuchsia")]
pub enum PerformanceCounterServiceRequest {
    Access(PerformanceCounterAccessRequestStream),
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceRequest for PerformanceCounterServiceRequest {
    type Service = PerformanceCounterServiceMarker;

    fn dispatch(name: &str, _channel: fidl::AsyncChannel) -> Self {
        match name {
            "access" => Self::Access(
                <PerformanceCounterAccessRequestStream as fidl::endpoints::RequestStream>::from_channel(_channel),
            ),
            _ => panic!("no such member protocol name for service PerformanceCounterService"),
        }
    }

    fn member_names() -> &'static [&'static str] {
        &["access"]
    }
}
#[cfg(target_os = "fuchsia")]
pub struct PerformanceCounterServiceProxy(
    #[allow(dead_code)] Box<dyn fidl::endpoints::MemberOpener>,
);

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceProxy for PerformanceCounterServiceProxy {
    type Service = PerformanceCounterServiceMarker;

    fn from_member_opener(opener: Box<dyn fidl::endpoints::MemberOpener>) -> Self {
        Self(opener)
    }
}

#[cfg(target_os = "fuchsia")]
impl PerformanceCounterServiceProxy {
    pub fn connect_to_access(&self) -> Result<PerformanceCounterAccessProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_proxy::<PerformanceCounterAccessMarker>();
        self.connect_channel_to_access(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_access`, but returns a sync proxy.
    /// See [`Self::connect_to_access`] for more details.
    pub fn connect_to_access_sync(
        &self,
    ) -> Result<PerformanceCounterAccessSynchronousProxy, fidl::Error> {
        let (proxy, server_end) =
            fidl::endpoints::create_sync_proxy::<PerformanceCounterAccessMarker>();
        self.connect_channel_to_access(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_access`, but accepts a server end.
    /// See [`Self::connect_to_access`] for more details.
    pub fn connect_channel_to_access(
        &self,
        server_end: fidl::endpoints::ServerEnd<PerformanceCounterAccessMarker>,
    ) -> Result<(), fidl::Error> {
        self.0.open_member("access", server_end.into_channel())
    }

    pub fn instance_name(&self) -> &str {
        self.0.instance_name()
    }
}

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

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceMarker for ServiceMarker {
    type Proxy = ServiceProxy;
    type Request = ServiceRequest;
    const SERVICE_NAME: &'static str = "fuchsia.gpu.magma.Service";
}

/// A request for one of the member protocols of Service.
///
#[cfg(target_os = "fuchsia")]
pub enum ServiceRequest {
    Device(CombinedDeviceRequestStream),
    PowerElementProvider(PowerElementProviderRequestStream),
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceRequest for ServiceRequest {
    type Service = ServiceMarker;

    fn dispatch(name: &str, _channel: fidl::AsyncChannel) -> Self {
        match name {
            "device" => Self::Device(
                <CombinedDeviceRequestStream as fidl::endpoints::RequestStream>::from_channel(
                    _channel,
                ),
            ),
            "power_element_provider" => Self::PowerElementProvider(
                <PowerElementProviderRequestStream as fidl::endpoints::RequestStream>::from_channel(
                    _channel,
                ),
            ),
            _ => panic!("no such member protocol name for service Service"),
        }
    }

    fn member_names() -> &'static [&'static str] {
        &["device", "power_element_provider"]
    }
}
#[cfg(target_os = "fuchsia")]
pub struct ServiceProxy(#[allow(dead_code)] Box<dyn fidl::endpoints::MemberOpener>);

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceProxy for ServiceProxy {
    type Service = ServiceMarker;

    fn from_member_opener(opener: Box<dyn fidl::endpoints::MemberOpener>) -> Self {
        Self(opener)
    }
}

#[cfg(target_os = "fuchsia")]
impl ServiceProxy {
    pub fn connect_to_device(&self) -> Result<CombinedDeviceProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_proxy::<CombinedDeviceMarker>();
        self.connect_channel_to_device(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_device`, but returns a sync proxy.
    /// See [`Self::connect_to_device`] for more details.
    pub fn connect_to_device_sync(&self) -> Result<CombinedDeviceSynchronousProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_sync_proxy::<CombinedDeviceMarker>();
        self.connect_channel_to_device(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_device`, but accepts a server end.
    /// See [`Self::connect_to_device`] for more details.
    pub fn connect_channel_to_device(
        &self,
        server_end: fidl::endpoints::ServerEnd<CombinedDeviceMarker>,
    ) -> Result<(), fidl::Error> {
        self.0.open_member("device", server_end.into_channel())
    }
    pub fn connect_to_power_element_provider(
        &self,
    ) -> Result<PowerElementProviderProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_proxy::<PowerElementProviderMarker>();
        self.connect_channel_to_power_element_provider(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_power_element_provider`, but returns a sync proxy.
    /// See [`Self::connect_to_power_element_provider`] for more details.
    pub fn connect_to_power_element_provider_sync(
        &self,
    ) -> Result<PowerElementProviderSynchronousProxy, fidl::Error> {
        let (proxy, server_end) =
            fidl::endpoints::create_sync_proxy::<PowerElementProviderMarker>();
        self.connect_channel_to_power_element_provider(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_power_element_provider`, but accepts a server end.
    /// See [`Self::connect_to_power_element_provider`] for more details.
    pub fn connect_channel_to_power_element_provider(
        &self,
        server_end: fidl::endpoints::ServerEnd<PowerElementProviderMarker>,
    ) -> Result<(), fidl::Error> {
        self.0.open_member("power_element_provider", server_end.into_channel())
    }

    pub fn instance_name(&self) -> &str {
        self.0.instance_name()
    }
}

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

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceMarker for TestServiceMarker {
    type Proxy = TestServiceProxy;
    type Request = TestServiceRequest;
    const SERVICE_NAME: &'static str = "fuchsia.gpu.magma.TestService";
}

/// A request for one of the member protocols of TestService.
///
/// This service is only exposed by test MSDs. This should not be used by an ICD.
#[cfg(target_os = "fuchsia")]
pub enum TestServiceRequest {
    Device(CombinedDeviceRequestStream),
    PowerElementProvider(PowerElementProviderRequestStream),
    TestDevice(TestDevice2RequestStream),
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceRequest for TestServiceRequest {
    type Service = TestServiceMarker;

    fn dispatch(name: &str, _channel: fidl::AsyncChannel) -> Self {
        match name {
            "device" => Self::Device(
                <CombinedDeviceRequestStream as fidl::endpoints::RequestStream>::from_channel(
                    _channel,
                ),
            ),
            "power_element_provider" => Self::PowerElementProvider(
                <PowerElementProviderRequestStream as fidl::endpoints::RequestStream>::from_channel(
                    _channel,
                ),
            ),
            "test_device" => Self::TestDevice(
                <TestDevice2RequestStream as fidl::endpoints::RequestStream>::from_channel(
                    _channel,
                ),
            ),
            _ => panic!("no such member protocol name for service TestService"),
        }
    }

    fn member_names() -> &'static [&'static str] {
        &["device", "power_element_provider", "test_device"]
    }
}
/// This service is only exposed by test MSDs. This should not be used by an ICD.
#[cfg(target_os = "fuchsia")]
pub struct TestServiceProxy(#[allow(dead_code)] Box<dyn fidl::endpoints::MemberOpener>);

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceProxy for TestServiceProxy {
    type Service = TestServiceMarker;

    fn from_member_opener(opener: Box<dyn fidl::endpoints::MemberOpener>) -> Self {
        Self(opener)
    }
}

#[cfg(target_os = "fuchsia")]
impl TestServiceProxy {
    pub fn connect_to_device(&self) -> Result<CombinedDeviceProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_proxy::<CombinedDeviceMarker>();
        self.connect_channel_to_device(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_device`, but returns a sync proxy.
    /// See [`Self::connect_to_device`] for more details.
    pub fn connect_to_device_sync(&self) -> Result<CombinedDeviceSynchronousProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_sync_proxy::<CombinedDeviceMarker>();
        self.connect_channel_to_device(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_device`, but accepts a server end.
    /// See [`Self::connect_to_device`] for more details.
    pub fn connect_channel_to_device(
        &self,
        server_end: fidl::endpoints::ServerEnd<CombinedDeviceMarker>,
    ) -> Result<(), fidl::Error> {
        self.0.open_member("device", server_end.into_channel())
    }
    pub fn connect_to_power_element_provider(
        &self,
    ) -> Result<PowerElementProviderProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_proxy::<PowerElementProviderMarker>();
        self.connect_channel_to_power_element_provider(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_power_element_provider`, but returns a sync proxy.
    /// See [`Self::connect_to_power_element_provider`] for more details.
    pub fn connect_to_power_element_provider_sync(
        &self,
    ) -> Result<PowerElementProviderSynchronousProxy, fidl::Error> {
        let (proxy, server_end) =
            fidl::endpoints::create_sync_proxy::<PowerElementProviderMarker>();
        self.connect_channel_to_power_element_provider(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_power_element_provider`, but accepts a server end.
    /// See [`Self::connect_to_power_element_provider`] for more details.
    pub fn connect_channel_to_power_element_provider(
        &self,
        server_end: fidl::endpoints::ServerEnd<PowerElementProviderMarker>,
    ) -> Result<(), fidl::Error> {
        self.0.open_member("power_element_provider", server_end.into_channel())
    }
    pub fn connect_to_test_device(&self) -> Result<TestDevice2Proxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_proxy::<TestDevice2Marker>();
        self.connect_channel_to_test_device(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_test_device`, but returns a sync proxy.
    /// See [`Self::connect_to_test_device`] for more details.
    pub fn connect_to_test_device_sync(&self) -> Result<TestDevice2SynchronousProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_sync_proxy::<TestDevice2Marker>();
        self.connect_channel_to_test_device(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_test_device`, but accepts a server end.
    /// See [`Self::connect_to_test_device`] for more details.
    pub fn connect_channel_to_test_device(
        &self,
        server_end: fidl::endpoints::ServerEnd<TestDevice2Marker>,
    ) -> Result<(), fidl::Error> {
        self.0.open_member("test_device", server_end.into_channel())
    }

    pub fn instance_name(&self) -> &str {
        self.0.instance_name()
    }
}

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

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceMarker for TrustedServiceMarker {
    type Proxy = TrustedServiceProxy;
    type Request = TrustedServiceRequest;
    const SERVICE_NAME: &'static str = "fuchsia.gpu.magma.TrustedService";
}

/// A request for one of the member protocols of TrustedService.
///
/// This service has additional abilities above the normal service.
#[cfg(target_os = "fuchsia")]
pub enum TrustedServiceRequest {
    Device(CombinedDeviceRequestStream),
    PowerElementProvider(PowerElementProviderRequestStream),
    DebugUtils(DebugUtilsRequestStream),
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceRequest for TrustedServiceRequest {
    type Service = TrustedServiceMarker;

    fn dispatch(name: &str, _channel: fidl::AsyncChannel) -> Self {
        match name {
            "device" => Self::Device(
                <CombinedDeviceRequestStream as fidl::endpoints::RequestStream>::from_channel(
                    _channel,
                ),
            ),
            "power_element_provider" => Self::PowerElementProvider(
                <PowerElementProviderRequestStream as fidl::endpoints::RequestStream>::from_channel(
                    _channel,
                ),
            ),
            "debug_utils" => Self::DebugUtils(
                <DebugUtilsRequestStream as fidl::endpoints::RequestStream>::from_channel(_channel),
            ),
            _ => panic!("no such member protocol name for service TrustedService"),
        }
    }

    fn member_names() -> &'static [&'static str] {
        &["device", "power_element_provider", "debug_utils"]
    }
}
/// This service has additional abilities above the normal service.
#[cfg(target_os = "fuchsia")]
pub struct TrustedServiceProxy(#[allow(dead_code)] Box<dyn fidl::endpoints::MemberOpener>);

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceProxy for TrustedServiceProxy {
    type Service = TrustedServiceMarker;

    fn from_member_opener(opener: Box<dyn fidl::endpoints::MemberOpener>) -> Self {
        Self(opener)
    }
}

#[cfg(target_os = "fuchsia")]
impl TrustedServiceProxy {
    pub fn connect_to_device(&self) -> Result<CombinedDeviceProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_proxy::<CombinedDeviceMarker>();
        self.connect_channel_to_device(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_device`, but returns a sync proxy.
    /// See [`Self::connect_to_device`] for more details.
    pub fn connect_to_device_sync(&self) -> Result<CombinedDeviceSynchronousProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_sync_proxy::<CombinedDeviceMarker>();
        self.connect_channel_to_device(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_device`, but accepts a server end.
    /// See [`Self::connect_to_device`] for more details.
    pub fn connect_channel_to_device(
        &self,
        server_end: fidl::endpoints::ServerEnd<CombinedDeviceMarker>,
    ) -> Result<(), fidl::Error> {
        self.0.open_member("device", server_end.into_channel())
    }
    pub fn connect_to_power_element_provider(
        &self,
    ) -> Result<PowerElementProviderProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_proxy::<PowerElementProviderMarker>();
        self.connect_channel_to_power_element_provider(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_power_element_provider`, but returns a sync proxy.
    /// See [`Self::connect_to_power_element_provider`] for more details.
    pub fn connect_to_power_element_provider_sync(
        &self,
    ) -> Result<PowerElementProviderSynchronousProxy, fidl::Error> {
        let (proxy, server_end) =
            fidl::endpoints::create_sync_proxy::<PowerElementProviderMarker>();
        self.connect_channel_to_power_element_provider(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_power_element_provider`, but accepts a server end.
    /// See [`Self::connect_to_power_element_provider`] for more details.
    pub fn connect_channel_to_power_element_provider(
        &self,
        server_end: fidl::endpoints::ServerEnd<PowerElementProviderMarker>,
    ) -> Result<(), fidl::Error> {
        self.0.open_member("power_element_provider", server_end.into_channel())
    }
    pub fn connect_to_debug_utils(&self) -> Result<DebugUtilsProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_proxy::<DebugUtilsMarker>();
        self.connect_channel_to_debug_utils(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_debug_utils`, but returns a sync proxy.
    /// See [`Self::connect_to_debug_utils`] for more details.
    pub fn connect_to_debug_utils_sync(&self) -> Result<DebugUtilsSynchronousProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_sync_proxy::<DebugUtilsMarker>();
        self.connect_channel_to_debug_utils(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_debug_utils`, but accepts a server end.
    /// See [`Self::connect_to_debug_utils`] for more details.
    pub fn connect_channel_to_debug_utils(
        &self,
        server_end: fidl::endpoints::ServerEnd<DebugUtilsMarker>,
    ) -> Result<(), fidl::Error> {
        self.0.open_member("debug_utils", server_end.into_channel())
    }

    pub fn instance_name(&self) -> &str {
        self.0.instance_name()
    }
}

mod internal {
    use super::*;

    impl fidl::encoding::ResourceTypeMarker for DependencyInjectionSetMemoryPressureProviderRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for DependencyInjectionSetMemoryPressureProviderRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                provider: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<fidl_fuchsia_memorypressure::ProviderMarker>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for DeviceConnect2Request {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<DeviceConnect2Request, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut DeviceConnect2Request
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceConnect2Request>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DeviceConnect2Request, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.client_id),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<PrimaryMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.primary_channel),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<NotificationMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.notification_channel),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<u64, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<PrimaryMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T2: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<NotificationMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<DeviceConnect2Request, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceConnect2Request>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            self.2.encode(encoder, offset + 12, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for DeviceConnect2Request
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                client_id: fidl::new_empty!(u64, fidl::encoding::DefaultFuchsiaResourceDialect),
                primary_channel: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<PrimaryMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                notification_channel: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<NotificationMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                u64,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.client_id,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<PrimaryMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.primary_channel,
                decoder,
                offset + 8,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<NotificationMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.notification_channel,
                decoder,
                offset + 12,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker
        for PerformanceCounterAccessGetPerformanceCountTokenResponse
    {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for PerformanceCounterAccessGetPerformanceCountTokenResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                access_token: fidl::new_empty!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for PowerElementProviderGetPowerGoalsResponse {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for PowerElementProviderGetPowerGoalsResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                goals: fidl::new_empty!(
                    fidl::encoding::UnboundedVector<PowerGoal>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for PrimaryCreatePerformanceCounterBufferPoolRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for PrimaryCreatePerformanceCounterBufferPoolRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                pool_id: fidl::new_empty!(u64, fidl::encoding::DefaultFuchsiaResourceDialect),
                event_channel: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<PerformanceCounterEventsMarker>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for PrimaryEnablePerformanceCounterAccessRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for PrimaryEnablePerformanceCounterAccessRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                access_token: fidl::new_empty!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

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

    impl PowerElementProviderGetClockSpeedLevelResponse {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.actual_hz {
                return 3;
            }
            if let Some(_) = self.level {
                return 2;
            }
            if let Some(_) = self.token {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for PowerElementProviderGetClockSpeedLevelResponse {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

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

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

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

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

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                fidl::encoding::HandleType<
                    fidl::Event,
                    { fidl::ObjectType::EVENT.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.token.as_mut().map(
                    <fidl::encoding::HandleType<
                        fidl::Event,
                        { fidl::ObjectType::EVENT.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

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

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

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

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

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

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

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

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

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

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

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

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

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

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

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

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

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

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

            next_offset += envelope_size;

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

            Ok(())
        }
    }

    impl PowerElementProviderSetClockLimitResponse {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.actual_hz {
                return 2;
            }
            if let Some(_) = self.handle {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for PowerElementProviderSetClockLimitResponse {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

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

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

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

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

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                fidl::encoding::HandleType<
                    fidl::EventPair,
                    { fidl::ObjectType::EVENTPAIR.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.handle.as_mut().map(
                    <fidl::encoding::HandleType<
                        fidl::EventPair,
                        { fidl::ObjectType::EVENTPAIR.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

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

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

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

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

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

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

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

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

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

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

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

            next_offset += envelope_size;

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

            Ok(())
        }
    }

    impl PowerGoal {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.token {
                return 2;
            }
            if let Some(_) = self.type_ {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for PowerGoal {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

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

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

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

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

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

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

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

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

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                fidl::encoding::HandleType<
                    fidl::Event,
                    { fidl::ObjectType::EVENT.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.token.as_mut().map(
                    <fidl::encoding::HandleType<
                        fidl::Event,
                        { fidl::ObjectType::EVENT.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

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

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

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

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

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

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

            next_offset += envelope_size;

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

            Ok(())
        }
    }

    impl PrimaryImportObjectRequest {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.flags {
                return 4;
            }
            if let Some(_) = self.object_id {
                return 3;
            }
            if let Some(_) = self.object_type {
                return 2;
            }
            if let Some(_) = self.object {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for PrimaryImportObjectRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

            next_offset += envelope_size;

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

            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for DeviceQueryResponse {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<DeviceQueryResponse, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut DeviceQueryResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceQueryResponse>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
                DeviceQueryResponse::SimpleResult(ref val) => fidl::encoding::encode_in_envelope::<
                    u64,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                DeviceQueryResponse::BufferResult(ref mut val) => {
                    fidl::encoding::encode_in_envelope::<
                        fidl::encoding::HandleType<
                            fidl::Vmo,
                            { fidl::ObjectType::VMO.into_raw() },
                            2147483648,
                        >,
                        fidl::encoding::DefaultFuchsiaResourceDialect,
                    >(
                        <fidl::encoding::HandleType<
                            fidl::Vmo,
                            { fidl::ObjectType::VMO.into_raw() },
                            2147483648,
                        > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                            val
                        ),
                        encoder,
                        offset + 8,
                        _depth,
                    )
                }
            }
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for DeviceQueryResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::SimpleResult(fidl::new_empty!(u64, fidl::encoding::DefaultFuchsiaResourceDialect))
        }

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

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

            if inlined != (member_inline_size <= 4) {
                return Err(fidl::Error::InvalidInlineBitInEnvelope);
            }
            let _inner_offset;
            if inlined {
                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
                _inner_offset = offset + 8;
            } else {
                depth.increment()?;
                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
            }
            match ordinal {
                1 => {
                    #[allow(irrefutable_let_patterns)]
                    if let DeviceQueryResponse::SimpleResult(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = DeviceQueryResponse::SimpleResult(fidl::new_empty!(
                            u64,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let DeviceQueryResponse::SimpleResult(ref mut val) = self {
                        fidl::decode!(
                            u64,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                2 => {
                    #[allow(irrefutable_let_patterns)]
                    if let DeviceQueryResponse::BufferResult(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = DeviceQueryResponse::BufferResult(
                            fidl::new_empty!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let DeviceQueryResponse::BufferResult(ref mut val) = self {
                        fidl::decode!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                ordinal => panic!("unexpected ordinal {:?}", ordinal),
            }
            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
                return Err(fidl::Error::InvalidNumBytesInEnvelope);
            }
            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for Object {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

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

    unsafe impl fidl::encoding::Encode<Object, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut Object
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Object>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
                Object::Semaphore(ref mut val) => fidl::encoding::encode_in_envelope::<
                    fidl::encoding::HandleType<
                        fidl::Event,
                        { fidl::ObjectType::EVENT.into_raw() },
                        2147483648,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <fidl::encoding::HandleType<
                        fidl::Event,
                        { fidl::ObjectType::EVENT.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        val
                    ),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                Object::Buffer(ref mut val) => fidl::encoding::encode_in_envelope::<
                    fidl::encoding::HandleType<
                        fidl::Vmo,
                        { fidl::ObjectType::VMO.into_raw() },
                        2147483648,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <fidl::encoding::HandleType<
                        fidl::Vmo,
                        { fidl::ObjectType::VMO.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        val
                    ),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                Object::VmoSemaphore(ref mut val) => fidl::encoding::encode_in_envelope::<
                    fidl::encoding::HandleType<
                        fidl::Vmo,
                        { fidl::ObjectType::VMO.into_raw() },
                        2147483648,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <fidl::encoding::HandleType<
                        fidl::Vmo,
                        { fidl::ObjectType::VMO.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        val
                    ),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                Object::CounterSemaphore(ref mut val) => fidl::encoding::encode_in_envelope::<
                    fidl::encoding::HandleType<
                        fidl::Counter,
                        { fidl::ObjectType::COUNTER.into_raw() },
                        2147483648,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <fidl::encoding::HandleType<
                        fidl::Counter,
                        { fidl::ObjectType::COUNTER.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        val
                    ),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                Object::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
            }
        }
    }

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

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

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

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