fidl_fuchsia_hardware_pci/

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

/// Describes and provides access to a given Base Address Register for the device.
#[derive(Debug, PartialEq)]
pub struct Bar {
    /// The BAR id, [0-5).
    pub bar_id: u32,
    pub size: u64,
    pub result: BarResult,
}

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

#[derive(Debug, PartialEq)]
pub struct DeviceGetBarResponse {
    pub result: Bar,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DeviceGetBtiResponse {
    pub bti: fidl::Bti,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DeviceMapInterruptResponse {
    pub interrupt: fidl::Interrupt,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct IoBar {
    pub address: u64,
    pub resource: fidl::Resource,
}

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

#[derive(Debug)]
pub enum BarResult {
    Io(IoBar),
    Vmo(fidl::Vmo),
    #[doc(hidden)]
    __SourceBreaking {
        unknown_ordinal: u64,
    },
}

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for DebugMarker {
    type Proxy = DebugProxy;
    type RequestStream = DebugRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = DebugSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.hardware.pci.Debug";
}
impl fidl::endpoints::DiscoverableProtocolMarker for DebugMarker {}
pub type DebugReadBarResult = Result<Vec<u8>, i32>;

pub trait DebugProxyInterface: Send + Sync {
    type GetHostBridgeInfoResponseFut: std::future::Future<Output = Result<HostBridgeInfo, fidl::Error>>
        + Send;
    fn r#get_host_bridge_info(&self) -> Self::GetHostBridgeInfoResponseFut;
    type GetDevicesResponseFut: std::future::Future<Output = Result<Vec<PciDevice>, fidl::Error>>
        + Send;
    fn r#get_devices(&self) -> Self::GetDevicesResponseFut;
    type ReadBarResponseFut: std::future::Future<Output = Result<DebugReadBarResult, fidl::Error>>
        + Send;
    fn r#read_bar(
        &self,
        device: &Address,
        bar_id: u8,
        offset: u64,
        size: u64,
    ) -> Self::ReadBarResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct DebugSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for DebugSynchronousProxy {
    type Proxy = DebugProxy;
    type Protocol = DebugMarker;

    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 DebugSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

    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<DebugEvent, fidl::Error> {
        DebugEvent::decode(self.client.wait_for_event::<DebugMarker>(deadline)?)
    }

    /// Retrieve information about the segment group and buses covered by a Bus.
    pub fn r#get_host_bridge_info(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<HostBridgeInfo, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            DebugGetHostBridgeInfoResponse,
            DebugMarker,
        >(
            (),
            0x2bbfcc65b0d1b151,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.info)
    }

    /// Retrieve all Devices on the Bus.
    pub fn r#get_devices(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Vec<PciDevice>, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, DebugGetDevicesResponse, DebugMarker>(
                (),
                0x79de7399f8487392,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.devices)
    }

    /// Read from a Device's base address register (BAR). The BAR must be an MMIO type.
    ///
    /// Parameters
    /// |device|: The address of the device to read from.
    /// |bar_id|: The ID of the BAR to read.
    /// |offset|: The offset, in bytes, to start the read (default: 0 bytes).
    /// |size|: The size of the read (default: 128 bytes). The max size for a
    /// read is |READBAR_MAX_SIZE|.
    ///
    /// Errors:
    /// |ZX_ERR_NOT_FOUND|: |device| was not found, or |bar_id| did not exist in |device|.
    /// |ZX_ERR_INVALID_ARGS|: |bar_id| is invalid,  or offset / size combined
    /// are invalid for the given BAR's size.
    /// |ZX_ERR_NOT_SUPPORTED|: The BAR specified by |bar_id| is not an MMIO BAR.
    pub fn r#read_bar(
        &self,
        mut device: &Address,
        mut bar_id: u8,
        mut offset: u64,
        mut size: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DebugReadBarResult, fidl::Error> {
        let _response = self.client.send_query::<
            DebugReadBarRequest,
            fidl::encoding::ResultType<DebugReadBarResponse, i32>,
            DebugMarker,
        >(
            (device, bar_id, offset, size,),
            0x36692ca178cbc3b4,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.buffer))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for DebugProxy {
    type Protocol = DebugMarker;

    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 DebugProxy {
    /// Create a new Proxy for fuchsia.hardware.pci/Debug.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <DebugMarker 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) -> DebugEventStream {
        DebugEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Retrieve information about the segment group and buses covered by a Bus.
    pub fn r#get_host_bridge_info(
        &self,
    ) -> fidl::client::QueryResponseFut<HostBridgeInfo, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        DebugProxyInterface::r#get_host_bridge_info(self)
    }

    /// Retrieve all Devices on the Bus.
    pub fn r#get_devices(
        &self,
    ) -> fidl::client::QueryResponseFut<Vec<PciDevice>, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        DebugProxyInterface::r#get_devices(self)
    }

    /// Read from a Device's base address register (BAR). The BAR must be an MMIO type.
    ///
    /// Parameters
    /// |device|: The address of the device to read from.
    /// |bar_id|: The ID of the BAR to read.
    /// |offset|: The offset, in bytes, to start the read (default: 0 bytes).
    /// |size|: The size of the read (default: 128 bytes). The max size for a
    /// read is |READBAR_MAX_SIZE|.
    ///
    /// Errors:
    /// |ZX_ERR_NOT_FOUND|: |device| was not found, or |bar_id| did not exist in |device|.
    /// |ZX_ERR_INVALID_ARGS|: |bar_id| is invalid,  or offset / size combined
    /// are invalid for the given BAR's size.
    /// |ZX_ERR_NOT_SUPPORTED|: The BAR specified by |bar_id| is not an MMIO BAR.
    pub fn r#read_bar(
        &self,
        mut device: &Address,
        mut bar_id: u8,
        mut offset: u64,
        mut size: u64,
    ) -> fidl::client::QueryResponseFut<
        DebugReadBarResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DebugProxyInterface::r#read_bar(self, device, bar_id, offset, size)
    }
}

impl DebugProxyInterface for DebugProxy {
    type GetHostBridgeInfoResponseFut = fidl::client::QueryResponseFut<
        HostBridgeInfo,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_host_bridge_info(&self) -> Self::GetHostBridgeInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<HostBridgeInfo, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DebugGetHostBridgeInfoResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2bbfcc65b0d1b151,
            >(_buf?)?;
            Ok(_response.info)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, HostBridgeInfo>(
            (),
            0x2bbfcc65b0d1b151,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

    type ReadBarResponseFut = fidl::client::QueryResponseFut<
        DebugReadBarResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#read_bar(
        &self,
        mut device: &Address,
        mut bar_id: u8,
        mut offset: u64,
        mut size: u64,
    ) -> Self::ReadBarResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DebugReadBarResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<DebugReadBarResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x36692ca178cbc3b4,
            >(_buf?)?;
            Ok(_response.map(|x| x.buffer))
        }
        self.client.send_query_and_decode::<DebugReadBarRequest, DebugReadBarResult>(
            (device, bar_id, offset, size),
            0x36692ca178cbc3b4,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.hardware.pci/Debug.
pub struct DebugRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for DebugRequestStream {
    type Protocol = DebugMarker;
    type ControlHandle = DebugControlHandle;

    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 {
        DebugControlHandle { 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 DebugRequestStream {
    type Item = Result<DebugRequest, 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 DebugRequestStream 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 {
                    0x2bbfcc65b0d1b151 => {
                        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 = DebugControlHandle { inner: this.inner.clone() };
                        Ok(DebugRequest::GetHostBridgeInfo {
                            responder: DebugGetHostBridgeInfoResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x79de7399f8487392 => {
                        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 = DebugControlHandle { inner: this.inner.clone() };
                        Ok(DebugRequest::GetDevices {
                            responder: DebugGetDevicesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x36692ca178cbc3b4 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DebugReadBarRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DebugReadBarRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DebugControlHandle { inner: this.inner.clone() };
                        Ok(DebugRequest::ReadBar {
                            device: req.device,
                            bar_id: req.bar_id,
                            offset: req.offset,
                            size: req.size,

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

/// The Debug protocol provides information about devices on a particular bus.
/// It is used for tools like lspci and not for driver operations.
#[derive(Debug)]
pub enum DebugRequest {
    /// Retrieve information about the segment group and buses covered by a Bus.
    GetHostBridgeInfo { responder: DebugGetHostBridgeInfoResponder },
    /// Retrieve all Devices on the Bus.
    GetDevices { responder: DebugGetDevicesResponder },
    /// Read from a Device's base address register (BAR). The BAR must be an MMIO type.
    ///
    /// Parameters
    /// |device|: The address of the device to read from.
    /// |bar_id|: The ID of the BAR to read.
    /// |offset|: The offset, in bytes, to start the read (default: 0 bytes).
    /// |size|: The size of the read (default: 128 bytes). The max size for a
    /// read is |READBAR_MAX_SIZE|.
    ///
    /// Errors:
    /// |ZX_ERR_NOT_FOUND|: |device| was not found, or |bar_id| did not exist in |device|.
    /// |ZX_ERR_INVALID_ARGS|: |bar_id| is invalid,  or offset / size combined
    /// are invalid for the given BAR's size.
    /// |ZX_ERR_NOT_SUPPORTED|: The BAR specified by |bar_id| is not an MMIO BAR.
    ReadBar {
        device: Address,
        bar_id: u8,
        offset: u64,
        size: u64,
        responder: DebugReadBarResponder,
    },
}

impl DebugRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_host_bridge_info(self) -> Option<(DebugGetHostBridgeInfoResponder)> {
        if let DebugRequest::GetHostBridgeInfo { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_devices(self) -> Option<(DebugGetDevicesResponder)> {
        if let DebugRequest::GetDevices { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_read_bar(self) -> Option<(Address, u8, u64, u64, DebugReadBarResponder)> {
        if let DebugRequest::ReadBar { device, bar_id, offset, size, responder } = self {
            Some((device, bar_id, offset, size, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            DebugRequest::GetHostBridgeInfo { .. } => "get_host_bridge_info",
            DebugRequest::GetDevices { .. } => "get_devices",
            DebugRequest::ReadBar { .. } => "read_bar",
        }
    }
}

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

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

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

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

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> 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 DebugControlHandle {}

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

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

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

    fn send_raw(&self, mut info: &HostBridgeInfo) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<DebugGetHostBridgeInfoResponse>(
            (info,),
            self.tx_id,
            0x2bbfcc65b0d1b151,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut devices: &[PciDevice]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<DebugGetDevicesResponse>(
            (devices,),
            self.tx_id,
            0x79de7399f8487392,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut result: Result<&[u8], i32>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<DebugReadBarResponse, i32>>(
            result.map(|buffer| (buffer,)),
            self.tx_id,
            0x36692ca178cbc3b4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[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 = "fuchsia.hardware.pci.Device";
}
impl fidl::endpoints::DiscoverableProtocolMarker for DeviceMarker {}
pub type DeviceGetBarResult = Result<Bar, i32>;
pub type DeviceSetBusMasteringResult = Result<(), i32>;
pub type DeviceResetDeviceResult = Result<(), i32>;
pub type DeviceAckInterruptResult = Result<(), i32>;
pub type DeviceMapInterruptResult = Result<fidl::Interrupt, i32>;
pub type DeviceSetInterruptModeResult = Result<(), i32>;
pub type DeviceReadConfig8Result = Result<u8, i32>;
pub type DeviceReadConfig16Result = Result<u16, i32>;
pub type DeviceReadConfig32Result = Result<u32, i32>;
pub type DeviceWriteConfig8Result = Result<(), i32>;
pub type DeviceWriteConfig16Result = Result<(), i32>;
pub type DeviceWriteConfig32Result = Result<(), i32>;
pub type DeviceGetBtiResult = Result<fidl::Bti, i32>;

pub trait DeviceProxyInterface: Send + Sync {
    type GetDeviceInfoResponseFut: std::future::Future<Output = Result<DeviceInfo, fidl::Error>>
        + Send;
    fn r#get_device_info(&self) -> Self::GetDeviceInfoResponseFut;
    type GetBarResponseFut: std::future::Future<Output = Result<DeviceGetBarResult, fidl::Error>>
        + Send;
    fn r#get_bar(&self, bar_id: u32) -> Self::GetBarResponseFut;
    type SetBusMasteringResponseFut: std::future::Future<Output = Result<DeviceSetBusMasteringResult, fidl::Error>>
        + Send;
    fn r#set_bus_mastering(&self, enabled: bool) -> Self::SetBusMasteringResponseFut;
    type ResetDeviceResponseFut: std::future::Future<Output = Result<DeviceResetDeviceResult, fidl::Error>>
        + Send;
    fn r#reset_device(&self) -> Self::ResetDeviceResponseFut;
    type AckInterruptResponseFut: std::future::Future<Output = Result<DeviceAckInterruptResult, fidl::Error>>
        + Send;
    fn r#ack_interrupt(&self) -> Self::AckInterruptResponseFut;
    type MapInterruptResponseFut: std::future::Future<Output = Result<DeviceMapInterruptResult, fidl::Error>>
        + Send;
    fn r#map_interrupt(&self, which_irq: u32) -> Self::MapInterruptResponseFut;
    type GetInterruptModesResponseFut: std::future::Future<Output = Result<InterruptModes, fidl::Error>>
        + Send;
    fn r#get_interrupt_modes(&self) -> Self::GetInterruptModesResponseFut;
    type SetInterruptModeResponseFut: std::future::Future<Output = Result<DeviceSetInterruptModeResult, fidl::Error>>
        + Send;
    fn r#set_interrupt_mode(
        &self,
        mode: InterruptMode,
        requested_irq_count: u32,
    ) -> Self::SetInterruptModeResponseFut;
    type ReadConfig8ResponseFut: std::future::Future<Output = Result<DeviceReadConfig8Result, fidl::Error>>
        + Send;
    fn r#read_config8(&self, offset: u16) -> Self::ReadConfig8ResponseFut;
    type ReadConfig16ResponseFut: std::future::Future<Output = Result<DeviceReadConfig16Result, fidl::Error>>
        + Send;
    fn r#read_config16(&self, offset: u16) -> Self::ReadConfig16ResponseFut;
    type ReadConfig32ResponseFut: std::future::Future<Output = Result<DeviceReadConfig32Result, fidl::Error>>
        + Send;
    fn r#read_config32(&self, offset: u16) -> Self::ReadConfig32ResponseFut;
    type WriteConfig8ResponseFut: std::future::Future<Output = Result<DeviceWriteConfig8Result, fidl::Error>>
        + Send;
    fn r#write_config8(&self, offset: u16, value: u8) -> Self::WriteConfig8ResponseFut;
    type WriteConfig16ResponseFut: std::future::Future<Output = Result<DeviceWriteConfig16Result, fidl::Error>>
        + Send;
    fn r#write_config16(&self, offset: u16, value: u16) -> Self::WriteConfig16ResponseFut;
    type WriteConfig32ResponseFut: std::future::Future<Output = Result<DeviceWriteConfig32Result, fidl::Error>>
        + Send;
    fn r#write_config32(&self, offset: u16, value: u32) -> Self::WriteConfig32ResponseFut;
    type GetCapabilitiesResponseFut: std::future::Future<Output = Result<Vec<u8>, fidl::Error>>
        + Send;
    fn r#get_capabilities(&self, id: CapabilityId) -> Self::GetCapabilitiesResponseFut;
    type GetExtendedCapabilitiesResponseFut: std::future::Future<Output = Result<Vec<u16>, fidl::Error>>
        + Send;
    fn r#get_extended_capabilities(
        &self,
        id: ExtendedCapabilityId,
    ) -> Self::GetExtendedCapabilitiesResponseFut;
    type GetBtiResponseFut: std::future::Future<Output = Result<DeviceGetBtiResult, fidl::Error>>
        + Send;
    fn r#get_bti(&self, index: u32) -> Self::GetBtiResponseFut;
}
#[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 {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

    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::<DeviceMarker>(deadline)?)
    }

    /// Returns a structure containing device information from the configuration header.
    pub fn r#get_device_info(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceInfo, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, DeviceGetDeviceInfoResponse, DeviceMarker>(
                (),
                0x5599d144d4329916,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.info)
    }

    /// Retrieves information for a specified Base Address Register (BAR). If the BAR contains
    /// MSI-X capability tables then an attempt will be made to return an MMIO region excluding
    /// those tables, if possible. Otherwise, an error will be returned.
    ///
    /// Parameters:
    /// |bar_id|: The id of the BAR being requested. Valid range is [0, 6).
    ///
    /// Errors:
    /// |ZX_ERR_ACCESS_DENIED|: The specified BAR does not have a driver-accessible region due to
    /// the presence of MSI-X tables. To use MSI-X see the |SetInterruptMode| method.
    /// |ZX_ERR_INTERNAL|: A bus driver error has occurred.
    /// |ZX_ERR_INVALID_ARGS|: The |bar_id| specified is outside of the acceptable range.
    /// |ZX_ERR_NOT_FOUND|: The specified |bar_id| does not exist for this device.
    pub fn r#get_bar(
        &self,
        mut bar_id: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceGetBarResult, fidl::Error> {
        let _response = self.client.send_query::<
            DeviceGetBarRequest,
            fidl::encoding::ResultType<DeviceGetBarResponse, i32>,
            DeviceMarker,
        >(
            (bar_id,),
            0x6b2683f6fbbff679,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.result))
    }

    /// Enables or disables the bus mastering capability for the device.
    ///
    /// Parameters:
    /// |enable|: true to enable bus mastering, false to disable.
    ///
    /// Errors:
    /// |ZX_ERR_BAD_STATE|: Method was called while the device is disabled.
    pub fn r#set_bus_mastering(
        &self,
        mut enabled: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceSetBusMasteringResult, fidl::Error> {
        let _response = self.client.send_query::<
            DeviceSetBusMasteringRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            DeviceMarker,
        >(
            (enabled,),
            0x3421e9e030211003,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Initiates a function level reset for the device. This is a synchronous
    /// operation that will not return ontil the reset is complete. Interrupt
    /// operation of the device must be disabled before initiating a reset.
    ///
    /// Errors:
    /// |ZX_ERR_BAD_STATE|: Interrupts were not disabled before calling |ResetDevice|.
    /// |ZX_ERR_NOT_SUPPORTED|: The device does not support reset.
    /// |ZX_ERR_TIMED_OUT|: The device did not complete its reset in the
    /// expected amount of time and is presumed to no longer be operating
    /// properly.
    pub fn r#reset_device(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceResetDeviceResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            DeviceMarker,
        >(
            (),
            0x3c5b7579bb6f8b9f,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Alerts the bus driver to deassert the raised legacy interrupt so that it
    /// may be waited on again. Only used if |SetInterruptMode| was called with
    /// |PCI_INTERRUPT_MODE_LEGACY|.
    ///
    /// Errors:
    /// |ZX_ERR_BAD_STATE|: device is not configured to use the Legacy interrupt mode.
    pub fn r#ack_interrupt(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceAckInterruptResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            DeviceMarker,
        >(
            (),
            0x70742f64692d5a6b,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Maps a device's interrupt to a zx:interrupt. The device's interrupt mode
    /// must already be configured with |SetInterruptMode|, and |which_irq| must
    /// be >= to the number of interrupts reported for that interrupt mode by
    /// |GetInterruptModes|. A Legacy interrupt may be mapped multiple times,
    /// but the handles will point to the same interrupt object. MSI & MSI-X
    /// interrupts may only have one outstanding mapping at a time per
    /// interrupt. Outstanding MSI & MSI-X interrupt handles must be closed
    /// before attempting to change the interrupt mode in a subsequent call to
    /// |SetInterruptMode|.
    ///
    /// Parameters:
    /// |which_irq|: The id of the interrupt to map.
    ///
    /// Errors:
    /// |ZX_ERR_ALREADY_BOUND|: The interrupt specified by |which_irq| is
    /// already mapped to a valid handle.
    /// |ZX_ERR_BAD_STATE|: interrupts are currently disabled for the device.
    /// |ZX_ERR_INVALID_ARGS|: |which_irq| is invalid for the mode.
    pub fn r#map_interrupt(
        &self,
        mut which_irq: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceMapInterruptResult, fidl::Error> {
        let _response = self.client.send_query::<
            DeviceMapInterruptRequest,
            fidl::encoding::ResultType<DeviceMapInterruptResponse, i32>,
            DeviceMarker,
        >(
            (which_irq,),
            0x25eeff9d34a1fa13,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.interrupt))
    }

    /// Returns the supported interrupt modes for a device.
    pub fn r#get_interrupt_modes(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<InterruptModes, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            DeviceGetInterruptModesResponse,
            DeviceMarker,
        >(
            (),
            0x93f4cd8f79e9f4a,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.modes)
    }

    /// Configures the interrupt mode for a device. When changing from one
    /// interrupt mode to another the driver must ensure existing interrupt
    /// handles are closed beforehand.
    ///
    /// Parameters:
    /// |mode|: The |InterruptMode| to request from the bus driver.
    /// |requested_irq_count|: The number of interrupts requested.
    ///
    /// Errors:
    /// |ZX_ERR_BAD_STATE|: The driver attempted to change interrupt mode while
    /// existing handles to mapped MSIs exist.
    /// |ZX_ERR_INVALID_ARGS|: |requested_irq_count| is 0.
    /// |ZX_ERR_NOT_SUPPORTED|: The provided |mode| is not supported, or invalid.
    pub fn r#set_interrupt_mode(
        &self,
        mut mode: InterruptMode,
        mut requested_irq_count: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceSetInterruptModeResult, fidl::Error> {
        let _response = self.client.send_query::<
            DeviceSetInterruptModeRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            DeviceMarker,
        >(
            (mode, requested_irq_count,),
            0x85bebad3eb24866,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Reads a byte from the device's configuration space. |Offset| must be
    /// within [0x0, 0xFF] if PCI, or [0x0, 0xFFF) if PCIe. In most cases a
    /// device will be PCIe.
    ///
    /// Parameters:
    /// |offset|: The offset into the device's configuration space to read.
    ///
    /// Errors:
    /// |ZX_ERR_OUT_OF_RANGE|: |offset| is an invalid address.
    pub fn r#read_config8(
        &self,
        mut offset: u16,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceReadConfig8Result, fidl::Error> {
        let _response = self.client.send_query::<
            DeviceReadConfig8Request,
            fidl::encoding::ResultType<DeviceReadConfig8Response, i32>,
            DeviceMarker,
        >(
            (offset,),
            0x28f9eb9e6dadda1c,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.value))
    }

    /// Reads two bytes from the device's configuration space. |Offset| must be
    /// within [0x0, 0xFE] if PCI, or [0x0, 0xFFE] if PCIe. In most cases a
    /// device will be PCIe.
    ///
    /// Parameters:
    /// |offset|: The offset into the device's configuration space to read.
    ///
    /// Errors:
    /// |ZX_ERR_OUT_OF_RANGE|: |offset| is an invalid address.
    pub fn r#read_config16(
        &self,
        mut offset: u16,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceReadConfig16Result, fidl::Error> {
        let _response = self.client.send_query::<
            DeviceReadConfig16Request,
            fidl::encoding::ResultType<DeviceReadConfig16Response, i32>,
            DeviceMarker,
        >(
            (offset,),
            0x3bcda6171a3270bb,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.value))
    }

    /// Reads four bytes from the device's configuration space. |Offset| must be
    /// within [0x0, 0xFC] if PCI, or [0x0, 0xFFC] if PCIe. In most cases a
    /// device will be PCIe.
    ///
    /// Parameters:
    /// |offset|: The offset into the device's configuration space to read.
    ///
    /// Errors:
    /// |ZX_ERR_OUT_OF_RANGE|: |offset| is an invalid address.
    pub fn r#read_config32(
        &self,
        mut offset: u16,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceReadConfig32Result, fidl::Error> {
        let _response = self.client.send_query::<
            DeviceReadConfig32Request,
            fidl::encoding::ResultType<DeviceReadConfig32Response, i32>,
            DeviceMarker,
        >(
            (offset,),
            0x55357535402f7507,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.value))
    }

    /// Writes a byte to the device's configuration space. The acceptable
    /// ranges of |offset| for writes are [0x40, 0xFF] if PCI, or [0x40,
    /// 0xFFF] if PCIe. For most purposes a device will be PCIe.
    ///
    ///
    /// Parameters
    /// |offset|: The offset into the device's configuration space to read.
    /// |value|: The value to write.
    ///
    /// Errors:
    /// |ZX_ERR_ACCESS_DENIED|: |offset| is within the device's configuration header.
    /// |ZX_ERR_OUT_OF_RANGE|: |offset| is an invalid address.
    pub fn r#write_config8(
        &self,
        mut offset: u16,
        mut value: u8,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceWriteConfig8Result, fidl::Error> {
        let _response = self.client.send_query::<
            DeviceWriteConfig8Request,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            DeviceMarker,
        >(
            (offset, value,),
            0x49a0719e1433cff,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Writes two bytes to the device's configuration space. The acceptable
    /// ranges of |offset| for writes are [0x40, 0xFE] if PCI, or [0x40,
    /// 0xFFE] if PCIe. For most purposes a device will be PCIe.
    ///
    ///
    /// Parameters
    /// |offset|: The offset into the device's configuration space to read.
    /// |value|: The value to write.
    ///
    /// Errors:
    /// |ZX_ERR_ACCESS_DENIED|: |offset| is within the device's configuration header.
    /// |ZX_ERR_OUT_OF_RANGE|: |offset| is an invalid address.
    pub fn r#write_config16(
        &self,
        mut offset: u16,
        mut value: u16,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceWriteConfig16Result, fidl::Error> {
        let _response = self.client.send_query::<
            DeviceWriteConfig16Request,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            DeviceMarker,
        >(
            (offset, value,),
            0x3e30bf13f1c07eff,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Writes four bytes to the device's configuration space. The acceptable
    /// ranges of |offset| for writes are [0x40, 0xFC] if PCI, or [0x40,
    /// 0xFFC] if PCIe. For most purposes a device will be PCIe.
    ///
    ///
    /// Parameters
    /// |offset|: The offset into the device's configuration space to read.
    /// |value|: The value to write.
    ///
    /// Errors:
    /// |ZX_ERR_ACCESS_DENIED|: |offset| is within the device's configuration header.
    /// |ZX_ERR_OUT_OF_RANGE|: |offset| is an invalid address.
    pub fn r#write_config32(
        &self,
        mut offset: u16,
        mut value: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceWriteConfig32Result, fidl::Error> {
        let _response = self.client.send_query::<
            DeviceWriteConfig32Request,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            DeviceMarker,
        >(
            (offset, value,),
            0x161584e5199b388,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Returns a vector of offsets in configuration space corresponding to
    /// capabilities matching the provided capability |id|.  If no corresponding
    /// match is found then the vector will be empty.
    ///
    /// Parameters:
    /// |id|: the capability id to search for.
    pub fn r#get_capabilities(
        &self,
        mut id: CapabilityId,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Vec<u8>, fidl::Error> {
        let _response = self.client.send_query::<
            DeviceGetCapabilitiesRequest,
            DeviceGetCapabilitiesResponse,
            DeviceMarker,
        >(
            (id,),
            0x3a050fde46f3ba0f,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.offsets)
    }

    /// Returns a vector of offsets in configuration space corresponding to
    /// extended capabilities matching the provided extended capability |id|.
    /// If no corresponding match is found then the vector will be empty.
    ///
    /// Parameters:
    /// |id|: the capability id to search for
    pub fn r#get_extended_capabilities(
        &self,
        mut id: ExtendedCapabilityId,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Vec<u16>, fidl::Error> {
        let _response = self.client.send_query::<
            DeviceGetExtendedCapabilitiesRequest,
            DeviceGetExtendedCapabilitiesResponse,
            DeviceMarker,
        >(
            (id,),
            0xb8573efcaae0c39,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.offsets)
    }

    /// Returns the Bus Transaction Intiator (BTI) at a given index for the device.
    ///
    /// Parameters:
    /// |index|: the BTI to request.
    ///
    /// Errors:
    /// |ZX_ERR_OUT_OF_RANGE|: |index| was not 0.
    pub fn r#get_bti(
        &self,
        mut index: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceGetBtiResult, fidl::Error> {
        let _response = self.client.send_query::<
            DeviceGetBtiRequest,
            fidl::encoding::ResultType<DeviceGetBtiResponse, i32>,
            DeviceMarker,
        >(
            (index,),
            0x5e4fe9efb12d9ee3,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.bti))
    }
}

#[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.hardware.pci/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() }
    }

    /// Returns a structure containing device information from the configuration header.
    pub fn r#get_device_info(
        &self,
    ) -> fidl::client::QueryResponseFut<DeviceInfo, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        DeviceProxyInterface::r#get_device_info(self)
    }

    /// Retrieves information for a specified Base Address Register (BAR). If the BAR contains
    /// MSI-X capability tables then an attempt will be made to return an MMIO region excluding
    /// those tables, if possible. Otherwise, an error will be returned.
    ///
    /// Parameters:
    /// |bar_id|: The id of the BAR being requested. Valid range is [0, 6).
    ///
    /// Errors:
    /// |ZX_ERR_ACCESS_DENIED|: The specified BAR does not have a driver-accessible region due to
    /// the presence of MSI-X tables. To use MSI-X see the |SetInterruptMode| method.
    /// |ZX_ERR_INTERNAL|: A bus driver error has occurred.
    /// |ZX_ERR_INVALID_ARGS|: The |bar_id| specified is outside of the acceptable range.
    /// |ZX_ERR_NOT_FOUND|: The specified |bar_id| does not exist for this device.
    pub fn r#get_bar(
        &self,
        mut bar_id: u32,
    ) -> fidl::client::QueryResponseFut<
        DeviceGetBarResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceProxyInterface::r#get_bar(self, bar_id)
    }

    /// Enables or disables the bus mastering capability for the device.
    ///
    /// Parameters:
    /// |enable|: true to enable bus mastering, false to disable.
    ///
    /// Errors:
    /// |ZX_ERR_BAD_STATE|: Method was called while the device is disabled.
    pub fn r#set_bus_mastering(
        &self,
        mut enabled: bool,
    ) -> fidl::client::QueryResponseFut<
        DeviceSetBusMasteringResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceProxyInterface::r#set_bus_mastering(self, enabled)
    }

    /// Initiates a function level reset for the device. This is a synchronous
    /// operation that will not return ontil the reset is complete. Interrupt
    /// operation of the device must be disabled before initiating a reset.
    ///
    /// Errors:
    /// |ZX_ERR_BAD_STATE|: Interrupts were not disabled before calling |ResetDevice|.
    /// |ZX_ERR_NOT_SUPPORTED|: The device does not support reset.
    /// |ZX_ERR_TIMED_OUT|: The device did not complete its reset in the
    /// expected amount of time and is presumed to no longer be operating
    /// properly.
    pub fn r#reset_device(
        &self,
    ) -> fidl::client::QueryResponseFut<
        DeviceResetDeviceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceProxyInterface::r#reset_device(self)
    }

    /// Alerts the bus driver to deassert the raised legacy interrupt so that it
    /// may be waited on again. Only used if |SetInterruptMode| was called with
    /// |PCI_INTERRUPT_MODE_LEGACY|.
    ///
    /// Errors:
    /// |ZX_ERR_BAD_STATE|: device is not configured to use the Legacy interrupt mode.
    pub fn r#ack_interrupt(
        &self,
    ) -> fidl::client::QueryResponseFut<
        DeviceAckInterruptResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceProxyInterface::r#ack_interrupt(self)
    }

    /// Maps a device's interrupt to a zx:interrupt. The device's interrupt mode
    /// must already be configured with |SetInterruptMode|, and |which_irq| must
    /// be >= to the number of interrupts reported for that interrupt mode by
    /// |GetInterruptModes|. A Legacy interrupt may be mapped multiple times,
    /// but the handles will point to the same interrupt object. MSI & MSI-X
    /// interrupts may only have one outstanding mapping at a time per
    /// interrupt. Outstanding MSI & MSI-X interrupt handles must be closed
    /// before attempting to change the interrupt mode in a subsequent call to
    /// |SetInterruptMode|.
    ///
    /// Parameters:
    /// |which_irq|: The id of the interrupt to map.
    ///
    /// Errors:
    /// |ZX_ERR_ALREADY_BOUND|: The interrupt specified by |which_irq| is
    /// already mapped to a valid handle.
    /// |ZX_ERR_BAD_STATE|: interrupts are currently disabled for the device.
    /// |ZX_ERR_INVALID_ARGS|: |which_irq| is invalid for the mode.
    pub fn r#map_interrupt(
        &self,
        mut which_irq: u32,
    ) -> fidl::client::QueryResponseFut<
        DeviceMapInterruptResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceProxyInterface::r#map_interrupt(self, which_irq)
    }

    /// Returns the supported interrupt modes for a device.
    pub fn r#get_interrupt_modes(
        &self,
    ) -> fidl::client::QueryResponseFut<InterruptModes, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        DeviceProxyInterface::r#get_interrupt_modes(self)
    }

    /// Configures the interrupt mode for a device. When changing from one
    /// interrupt mode to another the driver must ensure existing interrupt
    /// handles are closed beforehand.
    ///
    /// Parameters:
    /// |mode|: The |InterruptMode| to request from the bus driver.
    /// |requested_irq_count|: The number of interrupts requested.
    ///
    /// Errors:
    /// |ZX_ERR_BAD_STATE|: The driver attempted to change interrupt mode while
    /// existing handles to mapped MSIs exist.
    /// |ZX_ERR_INVALID_ARGS|: |requested_irq_count| is 0.
    /// |ZX_ERR_NOT_SUPPORTED|: The provided |mode| is not supported, or invalid.
    pub fn r#set_interrupt_mode(
        &self,
        mut mode: InterruptMode,
        mut requested_irq_count: u32,
    ) -> fidl::client::QueryResponseFut<
        DeviceSetInterruptModeResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceProxyInterface::r#set_interrupt_mode(self, mode, requested_irq_count)
    }

    /// Reads a byte from the device's configuration space. |Offset| must be
    /// within [0x0, 0xFF] if PCI, or [0x0, 0xFFF) if PCIe. In most cases a
    /// device will be PCIe.
    ///
    /// Parameters:
    /// |offset|: The offset into the device's configuration space to read.
    ///
    /// Errors:
    /// |ZX_ERR_OUT_OF_RANGE|: |offset| is an invalid address.
    pub fn r#read_config8(
        &self,
        mut offset: u16,
    ) -> fidl::client::QueryResponseFut<
        DeviceReadConfig8Result,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceProxyInterface::r#read_config8(self, offset)
    }

    /// Reads two bytes from the device's configuration space. |Offset| must be
    /// within [0x0, 0xFE] if PCI, or [0x0, 0xFFE] if PCIe. In most cases a
    /// device will be PCIe.
    ///
    /// Parameters:
    /// |offset|: The offset into the device's configuration space to read.
    ///
    /// Errors:
    /// |ZX_ERR_OUT_OF_RANGE|: |offset| is an invalid address.
    pub fn r#read_config16(
        &self,
        mut offset: u16,
    ) -> fidl::client::QueryResponseFut<
        DeviceReadConfig16Result,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceProxyInterface::r#read_config16(self, offset)
    }

    /// Reads four bytes from the device's configuration space. |Offset| must be
    /// within [0x0, 0xFC] if PCI, or [0x0, 0xFFC] if PCIe. In most cases a
    /// device will be PCIe.
    ///
    /// Parameters:
    /// |offset|: The offset into the device's configuration space to read.
    ///
    /// Errors:
    /// |ZX_ERR_OUT_OF_RANGE|: |offset| is an invalid address.
    pub fn r#read_config32(
        &self,
        mut offset: u16,
    ) -> fidl::client::QueryResponseFut<
        DeviceReadConfig32Result,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceProxyInterface::r#read_config32(self, offset)
    }

    /// Writes a byte to the device's configuration space. The acceptable
    /// ranges of |offset| for writes are [0x40, 0xFF] if PCI, or [0x40,
    /// 0xFFF] if PCIe. For most purposes a device will be PCIe.
    ///
    ///
    /// Parameters
    /// |offset|: The offset into the device's configuration space to read.
    /// |value|: The value to write.
    ///
    /// Errors:
    /// |ZX_ERR_ACCESS_DENIED|: |offset| is within the device's configuration header.
    /// |ZX_ERR_OUT_OF_RANGE|: |offset| is an invalid address.
    pub fn r#write_config8(
        &self,
        mut offset: u16,
        mut value: u8,
    ) -> fidl::client::QueryResponseFut<
        DeviceWriteConfig8Result,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceProxyInterface::r#write_config8(self, offset, value)
    }

    /// Writes two bytes to the device's configuration space. The acceptable
    /// ranges of |offset| for writes are [0x40, 0xFE] if PCI, or [0x40,
    /// 0xFFE] if PCIe. For most purposes a device will be PCIe.
    ///
    ///
    /// Parameters
    /// |offset|: The offset into the device's configuration space to read.
    /// |value|: The value to write.
    ///
    /// Errors:
    /// |ZX_ERR_ACCESS_DENIED|: |offset| is within the device's configuration header.
    /// |ZX_ERR_OUT_OF_RANGE|: |offset| is an invalid address.
    pub fn r#write_config16(
        &self,
        mut offset: u16,
        mut value: u16,
    ) -> fidl::client::QueryResponseFut<
        DeviceWriteConfig16Result,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceProxyInterface::r#write_config16(self, offset, value)
    }

    /// Writes four bytes to the device's configuration space. The acceptable
    /// ranges of |offset| for writes are [0x40, 0xFC] if PCI, or [0x40,
    /// 0xFFC] if PCIe. For most purposes a device will be PCIe.
    ///
    ///
    /// Parameters
    /// |offset|: The offset into the device's configuration space to read.
    /// |value|: The value to write.
    ///
    /// Errors:
    /// |ZX_ERR_ACCESS_DENIED|: |offset| is within the device's configuration header.
    /// |ZX_ERR_OUT_OF_RANGE|: |offset| is an invalid address.
    pub fn r#write_config32(
        &self,
        mut offset: u16,
        mut value: u32,
    ) -> fidl::client::QueryResponseFut<
        DeviceWriteConfig32Result,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceProxyInterface::r#write_config32(self, offset, value)
    }

    /// Returns a vector of offsets in configuration space corresponding to
    /// capabilities matching the provided capability |id|.  If no corresponding
    /// match is found then the vector will be empty.
    ///
    /// Parameters:
    /// |id|: the capability id to search for.
    pub fn r#get_capabilities(
        &self,
        mut id: CapabilityId,
    ) -> fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        DeviceProxyInterface::r#get_capabilities(self, id)
    }

    /// Returns a vector of offsets in configuration space corresponding to
    /// extended capabilities matching the provided extended capability |id|.
    /// If no corresponding match is found then the vector will be empty.
    ///
    /// Parameters:
    /// |id|: the capability id to search for
    pub fn r#get_extended_capabilities(
        &self,
        mut id: ExtendedCapabilityId,
    ) -> fidl::client::QueryResponseFut<Vec<u16>, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        DeviceProxyInterface::r#get_extended_capabilities(self, id)
    }

    /// Returns the Bus Transaction Intiator (BTI) at a given index for the device.
    ///
    /// Parameters:
    /// |index|: the BTI to request.
    ///
    /// Errors:
    /// |ZX_ERR_OUT_OF_RANGE|: |index| was not 0.
    pub fn r#get_bti(
        &self,
        mut index: u32,
    ) -> fidl::client::QueryResponseFut<
        DeviceGetBtiResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceProxyInterface::r#get_bti(self, index)
    }
}

impl DeviceProxyInterface for DeviceProxy {
    type GetDeviceInfoResponseFut =
        fidl::client::QueryResponseFut<DeviceInfo, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#get_device_info(&self) -> Self::GetDeviceInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceInfo, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DeviceGetDeviceInfoResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5599d144d4329916,
            >(_buf?)?;
            Ok(_response.info)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, DeviceInfo>(
            (),
            0x5599d144d4329916,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetBarResponseFut = fidl::client::QueryResponseFut<
        DeviceGetBarResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_bar(&self, mut bar_id: u32) -> Self::GetBarResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceGetBarResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<DeviceGetBarResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6b2683f6fbbff679,
            >(_buf?)?;
            Ok(_response.map(|x| x.result))
        }
        self.client.send_query_and_decode::<DeviceGetBarRequest, DeviceGetBarResult>(
            (bar_id,),
            0x6b2683f6fbbff679,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetBusMasteringResponseFut = fidl::client::QueryResponseFut<
        DeviceSetBusMasteringResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_bus_mastering(&self, mut enabled: bool) -> Self::SetBusMasteringResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceSetBusMasteringResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3421e9e030211003,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<DeviceSetBusMasteringRequest, DeviceSetBusMasteringResult>(
                (enabled,),
                0x3421e9e030211003,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

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

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

    type MapInterruptResponseFut = fidl::client::QueryResponseFut<
        DeviceMapInterruptResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#map_interrupt(&self, mut which_irq: u32) -> Self::MapInterruptResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceMapInterruptResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<DeviceMapInterruptResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x25eeff9d34a1fa13,
            >(_buf?)?;
            Ok(_response.map(|x| x.interrupt))
        }
        self.client.send_query_and_decode::<DeviceMapInterruptRequest, DeviceMapInterruptResult>(
            (which_irq,),
            0x25eeff9d34a1fa13,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

    type SetInterruptModeResponseFut = fidl::client::QueryResponseFut<
        DeviceSetInterruptModeResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_interrupt_mode(
        &self,
        mut mode: InterruptMode,
        mut requested_irq_count: u32,
    ) -> Self::SetInterruptModeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceSetInterruptModeResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x85bebad3eb24866,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<DeviceSetInterruptModeRequest, DeviceSetInterruptModeResult>(
                (mode, requested_irq_count),
                0x85bebad3eb24866,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type ReadConfig8ResponseFut = fidl::client::QueryResponseFut<
        DeviceReadConfig8Result,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#read_config8(&self, mut offset: u16) -> Self::ReadConfig8ResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceReadConfig8Result, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<DeviceReadConfig8Response, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x28f9eb9e6dadda1c,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<DeviceReadConfig8Request, DeviceReadConfig8Result>(
            (offset,),
            0x28f9eb9e6dadda1c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ReadConfig16ResponseFut = fidl::client::QueryResponseFut<
        DeviceReadConfig16Result,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#read_config16(&self, mut offset: u16) -> Self::ReadConfig16ResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceReadConfig16Result, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<DeviceReadConfig16Response, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3bcda6171a3270bb,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<DeviceReadConfig16Request, DeviceReadConfig16Result>(
            (offset,),
            0x3bcda6171a3270bb,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ReadConfig32ResponseFut = fidl::client::QueryResponseFut<
        DeviceReadConfig32Result,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#read_config32(&self, mut offset: u16) -> Self::ReadConfig32ResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceReadConfig32Result, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<DeviceReadConfig32Response, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x55357535402f7507,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<DeviceReadConfig32Request, DeviceReadConfig32Result>(
            (offset,),
            0x55357535402f7507,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type WriteConfig8ResponseFut = fidl::client::QueryResponseFut<
        DeviceWriteConfig8Result,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#write_config8(&self, mut offset: u16, mut value: u8) -> Self::WriteConfig8ResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceWriteConfig8Result, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x49a0719e1433cff,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<DeviceWriteConfig8Request, DeviceWriteConfig8Result>(
            (offset, value),
            0x49a0719e1433cff,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type WriteConfig16ResponseFut = fidl::client::QueryResponseFut<
        DeviceWriteConfig16Result,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#write_config16(&self, mut offset: u16, mut value: u16) -> Self::WriteConfig16ResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceWriteConfig16Result, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3e30bf13f1c07eff,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<DeviceWriteConfig16Request, DeviceWriteConfig16Result>(
            (offset, value),
            0x3e30bf13f1c07eff,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type WriteConfig32ResponseFut = fidl::client::QueryResponseFut<
        DeviceWriteConfig32Result,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#write_config32(&self, mut offset: u16, mut value: u32) -> Self::WriteConfig32ResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceWriteConfig32Result, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x161584e5199b388,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<DeviceWriteConfig32Request, DeviceWriteConfig32Result>(
            (offset, value),
            0x161584e5199b388,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetCapabilitiesResponseFut =
        fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#get_capabilities(&self, mut id: CapabilityId) -> Self::GetCapabilitiesResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<u8>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DeviceGetCapabilitiesResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3a050fde46f3ba0f,
            >(_buf?)?;
            Ok(_response.offsets)
        }
        self.client.send_query_and_decode::<DeviceGetCapabilitiesRequest, Vec<u8>>(
            (id,),
            0x3a050fde46f3ba0f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetExtendedCapabilitiesResponseFut =
        fidl::client::QueryResponseFut<Vec<u16>, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#get_extended_capabilities(
        &self,
        mut id: ExtendedCapabilityId,
    ) -> Self::GetExtendedCapabilitiesResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<u16>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DeviceGetExtendedCapabilitiesResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xb8573efcaae0c39,
            >(_buf?)?;
            Ok(_response.offsets)
        }
        self.client.send_query_and_decode::<DeviceGetExtendedCapabilitiesRequest, Vec<u16>>(
            (id,),
            0xb8573efcaae0c39,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetBtiResponseFut = fidl::client::QueryResponseFut<
        DeviceGetBtiResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_bti(&self, mut index: u32) -> Self::GetBtiResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceGetBtiResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<DeviceGetBtiResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5e4fe9efb12d9ee3,
            >(_buf?)?;
            Ok(_response.map(|x| x.bti))
        }
        self.client.send_query_and_decode::<DeviceGetBtiRequest, DeviceGetBtiResult>(
            (index,),
            0x5e4fe9efb12d9ee3,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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.hardware.pci/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 {
                    0x5599d144d4329916 => {
                        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 = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::GetDeviceInfo {
                            responder: DeviceGetDeviceInfoResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6b2683f6fbbff679 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceGetBarRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceGetBarRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::GetBar {
                            bar_id: req.bar_id,

                            responder: DeviceGetBarResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3421e9e030211003 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceSetBusMasteringRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceSetBusMasteringRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::SetBusMastering {
                            enabled: req.enabled,

                            responder: DeviceSetBusMasteringResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3c5b7579bb6f8b9f => {
                        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 = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::ResetDevice {
                            responder: DeviceResetDeviceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x70742f64692d5a6b => {
                        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 = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::AckInterrupt {
                            responder: DeviceAckInterruptResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x25eeff9d34a1fa13 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceMapInterruptRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceMapInterruptRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::MapInterrupt {
                            which_irq: req.which_irq,

                            responder: DeviceMapInterruptResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x93f4cd8f79e9f4a => {
                        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 = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::GetInterruptModes {
                            responder: DeviceGetInterruptModesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x85bebad3eb24866 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceSetInterruptModeRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceSetInterruptModeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::SetInterruptMode {
                            mode: req.mode,
                            requested_irq_count: req.requested_irq_count,

                            responder: DeviceSetInterruptModeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x28f9eb9e6dadda1c => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceReadConfig8Request,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceReadConfig8Request>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::ReadConfig8 {
                            offset: req.offset,

                            responder: DeviceReadConfig8Responder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3bcda6171a3270bb => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceReadConfig16Request,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceReadConfig16Request>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::ReadConfig16 {
                            offset: req.offset,

                            responder: DeviceReadConfig16Responder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x55357535402f7507 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceReadConfig32Request,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceReadConfig32Request>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::ReadConfig32 {
                            offset: req.offset,

                            responder: DeviceReadConfig32Responder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x49a0719e1433cff => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceWriteConfig8Request,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceWriteConfig8Request>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::WriteConfig8 {
                            offset: req.offset,
                            value: req.value,

                            responder: DeviceWriteConfig8Responder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3e30bf13f1c07eff => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceWriteConfig16Request,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceWriteConfig16Request>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::WriteConfig16 {
                            offset: req.offset,
                            value: req.value,

                            responder: DeviceWriteConfig16Responder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x161584e5199b388 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceWriteConfig32Request,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceWriteConfig32Request>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::WriteConfig32 {
                            offset: req.offset,
                            value: req.value,

                            responder: DeviceWriteConfig32Responder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3a050fde46f3ba0f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceGetCapabilitiesRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceGetCapabilitiesRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::GetCapabilities {
                            id: req.id,

                            responder: DeviceGetCapabilitiesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0xb8573efcaae0c39 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceGetExtendedCapabilitiesRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceGetExtendedCapabilitiesRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::GetExtendedCapabilities {
                            id: req.id,

                            responder: DeviceGetExtendedCapabilitiesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5e4fe9efb12d9ee3 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceGetBtiRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceGetBtiRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::GetBti {
                            index: req.index,

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

#[derive(Debug)]
pub enum DeviceRequest {
    /// Returns a structure containing device information from the configuration header.
    GetDeviceInfo { responder: DeviceGetDeviceInfoResponder },
    /// Retrieves information for a specified Base Address Register (BAR). If the BAR contains
    /// MSI-X capability tables then an attempt will be made to return an MMIO region excluding
    /// those tables, if possible. Otherwise, an error will be returned.
    ///
    /// Parameters:
    /// |bar_id|: The id of the BAR being requested. Valid range is [0, 6).
    ///
    /// Errors:
    /// |ZX_ERR_ACCESS_DENIED|: The specified BAR does not have a driver-accessible region due to
    /// the presence of MSI-X tables. To use MSI-X see the |SetInterruptMode| method.
    /// |ZX_ERR_INTERNAL|: A bus driver error has occurred.
    /// |ZX_ERR_INVALID_ARGS|: The |bar_id| specified is outside of the acceptable range.
    /// |ZX_ERR_NOT_FOUND|: The specified |bar_id| does not exist for this device.
    GetBar { bar_id: u32, responder: DeviceGetBarResponder },
    /// Enables or disables the bus mastering capability for the device.
    ///
    /// Parameters:
    /// |enable|: true to enable bus mastering, false to disable.
    ///
    /// Errors:
    /// |ZX_ERR_BAD_STATE|: Method was called while the device is disabled.
    SetBusMastering { enabled: bool, responder: DeviceSetBusMasteringResponder },
    /// Initiates a function level reset for the device. This is a synchronous
    /// operation that will not return ontil the reset is complete. Interrupt
    /// operation of the device must be disabled before initiating a reset.
    ///
    /// Errors:
    /// |ZX_ERR_BAD_STATE|: Interrupts were not disabled before calling |ResetDevice|.
    /// |ZX_ERR_NOT_SUPPORTED|: The device does not support reset.
    /// |ZX_ERR_TIMED_OUT|: The device did not complete its reset in the
    /// expected amount of time and is presumed to no longer be operating
    /// properly.
    ResetDevice { responder: DeviceResetDeviceResponder },
    /// Alerts the bus driver to deassert the raised legacy interrupt so that it
    /// may be waited on again. Only used if |SetInterruptMode| was called with
    /// |PCI_INTERRUPT_MODE_LEGACY|.
    ///
    /// Errors:
    /// |ZX_ERR_BAD_STATE|: device is not configured to use the Legacy interrupt mode.
    AckInterrupt { responder: DeviceAckInterruptResponder },
    /// Maps a device's interrupt to a zx:interrupt. The device's interrupt mode
    /// must already be configured with |SetInterruptMode|, and |which_irq| must
    /// be >= to the number of interrupts reported for that interrupt mode by
    /// |GetInterruptModes|. A Legacy interrupt may be mapped multiple times,
    /// but the handles will point to the same interrupt object. MSI & MSI-X
    /// interrupts may only have one outstanding mapping at a time per
    /// interrupt. Outstanding MSI & MSI-X interrupt handles must be closed
    /// before attempting to change the interrupt mode in a subsequent call to
    /// |SetInterruptMode|.
    ///
    /// Parameters:
    /// |which_irq|: The id of the interrupt to map.
    ///
    /// Errors:
    /// |ZX_ERR_ALREADY_BOUND|: The interrupt specified by |which_irq| is
    /// already mapped to a valid handle.
    /// |ZX_ERR_BAD_STATE|: interrupts are currently disabled for the device.
    /// |ZX_ERR_INVALID_ARGS|: |which_irq| is invalid for the mode.
    MapInterrupt { which_irq: u32, responder: DeviceMapInterruptResponder },
    /// Returns the supported interrupt modes for a device.
    GetInterruptModes { responder: DeviceGetInterruptModesResponder },
    /// Configures the interrupt mode for a device. When changing from one
    /// interrupt mode to another the driver must ensure existing interrupt
    /// handles are closed beforehand.
    ///
    /// Parameters:
    /// |mode|: The |InterruptMode| to request from the bus driver.
    /// |requested_irq_count|: The number of interrupts requested.
    ///
    /// Errors:
    /// |ZX_ERR_BAD_STATE|: The driver attempted to change interrupt mode while
    /// existing handles to mapped MSIs exist.
    /// |ZX_ERR_INVALID_ARGS|: |requested_irq_count| is 0.
    /// |ZX_ERR_NOT_SUPPORTED|: The provided |mode| is not supported, or invalid.
    SetInterruptMode {
        mode: InterruptMode,
        requested_irq_count: u32,
        responder: DeviceSetInterruptModeResponder,
    },
    /// Reads a byte from the device's configuration space. |Offset| must be
    /// within [0x0, 0xFF] if PCI, or [0x0, 0xFFF) if PCIe. In most cases a
    /// device will be PCIe.
    ///
    /// Parameters:
    /// |offset|: The offset into the device's configuration space to read.
    ///
    /// Errors:
    /// |ZX_ERR_OUT_OF_RANGE|: |offset| is an invalid address.
    ReadConfig8 { offset: u16, responder: DeviceReadConfig8Responder },
    /// Reads two bytes from the device's configuration space. |Offset| must be
    /// within [0x0, 0xFE] if PCI, or [0x0, 0xFFE] if PCIe. In most cases a
    /// device will be PCIe.
    ///
    /// Parameters:
    /// |offset|: The offset into the device's configuration space to read.
    ///
    /// Errors:
    /// |ZX_ERR_OUT_OF_RANGE|: |offset| is an invalid address.
    ReadConfig16 { offset: u16, responder: DeviceReadConfig16Responder },
    /// Reads four bytes from the device's configuration space. |Offset| must be
    /// within [0x0, 0xFC] if PCI, or [0x0, 0xFFC] if PCIe. In most cases a
    /// device will be PCIe.
    ///
    /// Parameters:
    /// |offset|: The offset into the device's configuration space to read.
    ///
    /// Errors:
    /// |ZX_ERR_OUT_OF_RANGE|: |offset| is an invalid address.
    ReadConfig32 { offset: u16, responder: DeviceReadConfig32Responder },
    /// Writes a byte to the device's configuration space. The acceptable
    /// ranges of |offset| for writes are [0x40, 0xFF] if PCI, or [0x40,
    /// 0xFFF] if PCIe. For most purposes a device will be PCIe.
    ///
    ///
    /// Parameters
    /// |offset|: The offset into the device's configuration space to read.
    /// |value|: The value to write.
    ///
    /// Errors:
    /// |ZX_ERR_ACCESS_DENIED|: |offset| is within the device's configuration header.
    /// |ZX_ERR_OUT_OF_RANGE|: |offset| is an invalid address.
    WriteConfig8 { offset: u16, value: u8, responder: DeviceWriteConfig8Responder },
    /// Writes two bytes to the device's configuration space. The acceptable
    /// ranges of |offset| for writes are [0x40, 0xFE] if PCI, or [0x40,
    /// 0xFFE] if PCIe. For most purposes a device will be PCIe.
    ///
    ///
    /// Parameters
    /// |offset|: The offset into the device's configuration space to read.
    /// |value|: The value to write.
    ///
    /// Errors:
    /// |ZX_ERR_ACCESS_DENIED|: |offset| is within the device's configuration header.
    /// |ZX_ERR_OUT_OF_RANGE|: |offset| is an invalid address.
    WriteConfig16 { offset: u16, value: u16, responder: DeviceWriteConfig16Responder },
    /// Writes four bytes to the device's configuration space. The acceptable
    /// ranges of |offset| for writes are [0x40, 0xFC] if PCI, or [0x40,
    /// 0xFFC] if PCIe. For most purposes a device will be PCIe.
    ///
    ///
    /// Parameters
    /// |offset|: The offset into the device's configuration space to read.
    /// |value|: The value to write.
    ///
    /// Errors:
    /// |ZX_ERR_ACCESS_DENIED|: |offset| is within the device's configuration header.
    /// |ZX_ERR_OUT_OF_RANGE|: |offset| is an invalid address.
    WriteConfig32 { offset: u16, value: u32, responder: DeviceWriteConfig32Responder },
    /// Returns a vector of offsets in configuration space corresponding to
    /// capabilities matching the provided capability |id|.  If no corresponding
    /// match is found then the vector will be empty.
    ///
    /// Parameters:
    /// |id|: the capability id to search for.
    GetCapabilities { id: CapabilityId, responder: DeviceGetCapabilitiesResponder },
    /// Returns a vector of offsets in configuration space corresponding to
    /// extended capabilities matching the provided extended capability |id|.
    /// If no corresponding match is found then the vector will be empty.
    ///
    /// Parameters:
    /// |id|: the capability id to search for
    GetExtendedCapabilities {
        id: ExtendedCapabilityId,
        responder: DeviceGetExtendedCapabilitiesResponder,
    },
    /// Returns the Bus Transaction Intiator (BTI) at a given index for the device.
    ///
    /// Parameters:
    /// |index|: the BTI to request.
    ///
    /// Errors:
    /// |ZX_ERR_OUT_OF_RANGE|: |index| was not 0.
    GetBti { index: u32, responder: DeviceGetBtiResponder },
}

impl DeviceRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_device_info(self) -> Option<(DeviceGetDeviceInfoResponder)> {
        if let DeviceRequest::GetDeviceInfo { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_bar(self) -> Option<(u32, DeviceGetBarResponder)> {
        if let DeviceRequest::GetBar { bar_id, responder } = self {
            Some((bar_id, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_bus_mastering(self) -> Option<(bool, DeviceSetBusMasteringResponder)> {
        if let DeviceRequest::SetBusMastering { enabled, responder } = self {
            Some((enabled, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_reset_device(self) -> Option<(DeviceResetDeviceResponder)> {
        if let DeviceRequest::ResetDevice { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_ack_interrupt(self) -> Option<(DeviceAckInterruptResponder)> {
        if let DeviceRequest::AckInterrupt { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_map_interrupt(self) -> Option<(u32, DeviceMapInterruptResponder)> {
        if let DeviceRequest::MapInterrupt { which_irq, responder } = self {
            Some((which_irq, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_interrupt_modes(self) -> Option<(DeviceGetInterruptModesResponder)> {
        if let DeviceRequest::GetInterruptModes { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_interrupt_mode(
        self,
    ) -> Option<(InterruptMode, u32, DeviceSetInterruptModeResponder)> {
        if let DeviceRequest::SetInterruptMode { mode, requested_irq_count, responder } = self {
            Some((mode, requested_irq_count, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_read_config8(self) -> Option<(u16, DeviceReadConfig8Responder)> {
        if let DeviceRequest::ReadConfig8 { offset, responder } = self {
            Some((offset, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_read_config16(self) -> Option<(u16, DeviceReadConfig16Responder)> {
        if let DeviceRequest::ReadConfig16 { offset, responder } = self {
            Some((offset, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_read_config32(self) -> Option<(u16, DeviceReadConfig32Responder)> {
        if let DeviceRequest::ReadConfig32 { offset, responder } = self {
            Some((offset, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_write_config8(self) -> Option<(u16, u8, DeviceWriteConfig8Responder)> {
        if let DeviceRequest::WriteConfig8 { offset, value, responder } = self {
            Some((offset, value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_write_config16(self) -> Option<(u16, u16, DeviceWriteConfig16Responder)> {
        if let DeviceRequest::WriteConfig16 { offset, value, responder } = self {
            Some((offset, value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_write_config32(self) -> Option<(u16, u32, DeviceWriteConfig32Responder)> {
        if let DeviceRequest::WriteConfig32 { offset, value, responder } = self {
            Some((offset, value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_capabilities(self) -> Option<(CapabilityId, DeviceGetCapabilitiesResponder)> {
        if let DeviceRequest::GetCapabilities { id, responder } = self {
            Some((id, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_extended_capabilities(
        self,
    ) -> Option<(ExtendedCapabilityId, DeviceGetExtendedCapabilitiesResponder)> {
        if let DeviceRequest::GetExtendedCapabilities { id, responder } = self {
            Some((id, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_bti(self) -> Option<(u32, DeviceGetBtiResponder)> {
        if let DeviceRequest::GetBti { index, responder } = self {
            Some((index, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            DeviceRequest::GetDeviceInfo { .. } => "get_device_info",
            DeviceRequest::GetBar { .. } => "get_bar",
            DeviceRequest::SetBusMastering { .. } => "set_bus_mastering",
            DeviceRequest::ResetDevice { .. } => "reset_device",
            DeviceRequest::AckInterrupt { .. } => "ack_interrupt",
            DeviceRequest::MapInterrupt { .. } => "map_interrupt",
            DeviceRequest::GetInterruptModes { .. } => "get_interrupt_modes",
            DeviceRequest::SetInterruptMode { .. } => "set_interrupt_mode",
            DeviceRequest::ReadConfig8 { .. } => "read_config8",
            DeviceRequest::ReadConfig16 { .. } => "read_config16",
            DeviceRequest::ReadConfig32 { .. } => "read_config32",
            DeviceRequest::WriteConfig8 { .. } => "write_config8",
            DeviceRequest::WriteConfig16 { .. } => "write_config16",
            DeviceRequest::WriteConfig32 { .. } => "write_config32",
            DeviceRequest::GetCapabilities { .. } => "get_capabilities",
            DeviceRequest::GetExtendedCapabilities { .. } => "get_extended_capabilities",
            DeviceRequest::GetBti { .. } => "get_bti",
        }
    }
}

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

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

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

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

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> 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 DeviceGetDeviceInfoResponder {
    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 DeviceGetDeviceInfoResponder {
    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 DeviceGetDeviceInfoResponder {
    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 DeviceGetDeviceInfoResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut info: &DeviceInfo) -> Result<(), fidl::Error> {
        let _result = self.send_raw(info);
        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 info: &DeviceInfo) -> Result<(), fidl::Error> {
        let _result = self.send_raw(info);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut info: &DeviceInfo) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<DeviceGetDeviceInfoResponse>(
            (info,),
            self.tx_id,
            0x5599d144d4329916,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DeviceGetBarResponder {
    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 DeviceGetBarResponder {
    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 DeviceGetBarResponder {
    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 DeviceGetBarResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<Bar, 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<Bar, i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

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

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DeviceSetBusMasteringResponder {
    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 DeviceSetBusMasteringResponder {
    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 DeviceSetBusMasteringResponder {
    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 DeviceSetBusMasteringResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

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

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

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DeviceResetDeviceResponder {
    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 DeviceResetDeviceResponder {
    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 DeviceResetDeviceResponder {
    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 DeviceResetDeviceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

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

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

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DeviceAckInterruptResponder {
    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 DeviceAckInterruptResponder {
    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 DeviceAckInterruptResponder {
    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 DeviceAckInterruptResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

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

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

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DeviceMapInterruptResponder {
    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 DeviceMapInterruptResponder {
    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 DeviceMapInterruptResponder {
    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 DeviceMapInterruptResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<fidl::Interrupt, i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

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

    fn send_raw(&self, mut result: Result<fidl::Interrupt, i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<DeviceMapInterruptResponse, i32>>(
                result.map(|interrupt| (interrupt,)),
                self.tx_id,
                0x25eeff9d34a1fa13,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DeviceGetInterruptModesResponder {
    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 DeviceGetInterruptModesResponder {
    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 DeviceGetInterruptModesResponder {
    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 DeviceGetInterruptModesResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut modes: &InterruptModes) -> Result<(), fidl::Error> {
        let _result = self.send_raw(modes);
        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 modes: &InterruptModes) -> Result<(), fidl::Error> {
        let _result = self.send_raw(modes);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut modes: &InterruptModes) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<DeviceGetInterruptModesResponse>(
            (modes,),
            self.tx_id,
            0x93f4cd8f79e9f4a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DeviceSetInterruptModeResponder {
    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 DeviceSetInterruptModeResponder {
    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 DeviceSetInterruptModeResponder {
    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 DeviceSetInterruptModeResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

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

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

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DeviceReadConfig8Responder {
    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 DeviceReadConfig8Responder {
    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 DeviceReadConfig8Responder {
    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 DeviceReadConfig8Responder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<u8, 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<u8, i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<u8, i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<DeviceReadConfig8Response, i32>>(
                result.map(|value| (value,)),
                self.tx_id,
                0x28f9eb9e6dadda1c,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DeviceReadConfig16Responder {
    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 DeviceReadConfig16Responder {
    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 DeviceReadConfig16Responder {
    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 DeviceReadConfig16Responder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<u16, 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<u16, i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<u16, i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<DeviceReadConfig16Response, i32>>(
                result.map(|value| (value,)),
                self.tx_id,
                0x3bcda6171a3270bb,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DeviceReadConfig32Responder {
    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 DeviceReadConfig32Responder {
    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 DeviceReadConfig32Responder {
    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 DeviceReadConfig32Responder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<u32, 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<u32, i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<u32, i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<DeviceReadConfig32Response, i32>>(
                result.map(|value| (value,)),
                self.tx_id,
                0x55357535402f7507,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DeviceWriteConfig8Responder {
    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 DeviceWriteConfig8Responder {
    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 DeviceWriteConfig8Responder {
    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 DeviceWriteConfig8Responder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

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

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

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DeviceWriteConfig16Responder {
    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 DeviceWriteConfig16Responder {
    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 DeviceWriteConfig16Responder {
    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 DeviceWriteConfig16Responder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

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

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

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DeviceWriteConfig32Responder {
    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 DeviceWriteConfig32Responder {
    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 DeviceWriteConfig32Responder {
    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 DeviceWriteConfig32Responder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

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

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

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DeviceGetCapabilitiesResponder {
    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 DeviceGetCapabilitiesResponder {
    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 DeviceGetCapabilitiesResponder {
    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 DeviceGetCapabilitiesResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut offsets: &[u8]) -> Result<(), fidl::Error> {
        let _result = self.send_raw(offsets);
        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 offsets: &[u8]) -> Result<(), fidl::Error> {
        let _result = self.send_raw(offsets);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut offsets: &[u8]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<DeviceGetCapabilitiesResponse>(
            (offsets,),
            self.tx_id,
            0x3a050fde46f3ba0f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DeviceGetExtendedCapabilitiesResponder {
    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 DeviceGetExtendedCapabilitiesResponder {
    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 DeviceGetExtendedCapabilitiesResponder {
    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 DeviceGetExtendedCapabilitiesResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut offsets: &[u16]) -> Result<(), fidl::Error> {
        let _result = self.send_raw(offsets);
        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 offsets: &[u16]) -> Result<(), fidl::Error> {
        let _result = self.send_raw(offsets);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut offsets: &[u16]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<DeviceGetExtendedCapabilitiesResponse>(
            (offsets,),
            self.tx_id,
            0xb8573efcaae0c39,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DeviceGetBtiResponder {
    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 DeviceGetBtiResponder {
    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 DeviceGetBtiResponder {
    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 DeviceGetBtiResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<fidl::Bti, i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

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

    fn send_raw(&self, mut result: Result<fidl::Bti, i32>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<DeviceGetBtiResponse, i32>>(
            result.map(|bti| (bti,)),
            self.tx_id,
            0x5e4fe9efb12d9ee3,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceMarker for DebugServiceMarker {
    type Proxy = DebugServiceProxy;
    type Request = DebugServiceRequest;
    const SERVICE_NAME: &'static str = "fuchsia.hardware.pci.DebugService";
}

/// A request for one of the member protocols of DebugService.
///
#[cfg(target_os = "fuchsia")]
pub enum DebugServiceRequest {
    Debug(DebugRequestStream),
}

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

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

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

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

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

#[cfg(target_os = "fuchsia")]
impl DebugServiceProxy {
    pub fn connect_to_debug(&self) -> Result<DebugProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_proxy::<DebugMarker>();
        self.connect_channel_to_debug(server_end)?;
        Ok(proxy)
    }

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

    /// Like `connect_to_debug`, but accepts a server end.
    /// See [`Self::connect_to_debug`] for more details.
    pub fn connect_channel_to_debug(
        &self,
        server_end: fidl::endpoints::ServerEnd<DebugMarker>,
    ) -> Result<(), fidl::Error> {
        self.0.open_member("debug", 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.hardware.pci.Service";
}

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

#[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(
                <DeviceRequestStream as fidl::endpoints::RequestStream>::from_channel(_channel),
            ),
            _ => panic!("no such member protocol name for service Service"),
        }
    }

    fn member_names() -> &'static [&'static str] {
        &["device"]
    }
}
#[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<DeviceProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_proxy::<DeviceMarker>();
        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<DeviceSynchronousProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_sync_proxy::<DeviceMarker>();
        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<DeviceMarker>,
    ) -> Result<(), fidl::Error> {
        self.0.open_member("device", server_end.into_channel())
    }

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

mod internal {
    use super::*;

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for Bar {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                bar_id: fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect),
                size: fidl::new_empty!(u64, fidl::encoding::DefaultFuchsiaResourceDialect),
                result: fidl::new_empty!(BarResult, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

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

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

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

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

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

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

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

    impl fidl::encoding::ResourceTypeMarker for IoBar {
        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 IoBar {
        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<IoBar, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut IoBar
    {
        #[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::<IoBar>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<IoBar, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.address),
                    <fidl::encoding::HandleType<
                        fidl::Resource,
                        { fidl::ObjectType::RESOURCE.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.resource
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<u64, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::Resource,
                    { fidl::ObjectType::RESOURCE.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    > fidl::encoding::Encode<IoBar, 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::<IoBar>(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 IoBar {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                address: fidl::new_empty!(u64, fidl::encoding::DefaultFuchsiaResourceDialect),
                resource: fidl::new_empty!(fidl::encoding::HandleType<fidl::Resource, { fidl::ObjectType::RESOURCE.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.
            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.address,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(fidl::encoding::HandleType<fidl::Resource, { fidl::ObjectType::RESOURCE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.resource, decoder, offset + 8, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for BarResult {
        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 BarResult {
        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<BarResult, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut BarResult
    {
        #[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::<BarResult>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
                BarResult::Io(ref mut val) => fidl::encoding::encode_in_envelope::<
                    IoBar,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <IoBar as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                BarResult::Vmo(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,
                ),
                BarResult::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
            }
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for BarResult {
        #[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 => <IoBar as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                2 => <fidl::encoding::HandleType<
                    fidl::Vmo,
                    { fidl::ObjectType::VMO.into_raw() },
                    2147483648,
                > as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                0 => return Err(fidl::Error::UnknownUnionTag),
                _ => num_bytes as usize,
            };

            if inlined != (member_inline_size <= 4) {
                return Err(fidl::Error::InvalidInlineBitInEnvelope);
            }
            let _inner_offset;
            if inlined {
                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
                _inner_offset = offset + 8;
            } else {
                depth.increment()?;
                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
            }
            match ordinal {
                1 => {
                    #[allow(irrefutable_let_patterns)]
                    if let BarResult::Io(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = BarResult::Io(fidl::new_empty!(
                            IoBar,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let BarResult::Io(ref mut val) = self {
                        fidl::decode!(
                            IoBar,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                2 => {
                    #[allow(irrefutable_let_patterns)]
                    if let BarResult::Vmo(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = BarResult::Vmo(
                            fidl::new_empty!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let BarResult::Vmo(ref mut val) = self {
                        fidl::decode!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                #[allow(deprecated)]
                ordinal => {
                    for _ in 0..num_handles {
                        decoder.drop_next_handle()?;
                    }
                    *self = BarResult::__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(())
        }
    }
}