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

// fidl_experiment = no_optional_structs
// fidl_experiment = transitional_allow_list
// fidl_experiment = unknown_interactions
// fidl_experiment = unknown_interactions_mandate

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

use {
    bitflags::bitflags,
    fidl::{
        client::QueryResponseFut,
        endpoints::{ControlHandle as _, Responder as _},
    },
    fuchsia_zircon_status as zx_status,
    futures::future::{self, MaybeDone, TryFutureExt},
};

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

pub const BIND_RULES_INSTRUCTIONS_MAX: u32 = 256;

/// Maximum number of bytes in a device arguments string.
pub const DEVICE_ARGS_MAX: u32 = 1024;

/// Maximum number of parts that a composite device fragment can have
pub const DEVICE_FRAGMENT_PARTS_MAX: u32 = 16;

/// Maximum number of instructions in the match program of a device fragment part
pub const DEVICE_FRAGMENT_PART_INSTRUCTIONS_MAX: u32 = 32;

/// This definition must match `ZX_DEVICE_NAME_MAX` and is checked by a static assert.
pub const DEVICE_NAME_MAX: u32 = 31;

/// Maximum number of bytes in a path
pub const DEVICE_PATH_MAX: u32 = 1024;

/// Maximum number of fragments that a composite device can have
pub const FRAGMENTS_MAX: u32 = 16;

pub const FRAGMENT_NAME_MAX: u32 = 32;

/// Maximum length of a dispatcher scheduler role.
pub const MAX_SCHEDULER_ROLE_LENGTH: u32 = 2048;

/// The number of variants of `SystemPowerState`.
pub const MAX_SYSTEM_POWER_STATES: u32 = 8;

/// Maximum number of bytes in a metadata payload
pub const METADATA_BYTES_MAX: u32 = 8192;

/// Maximum number of metadata that can be added to a device
pub const METADATA_MAX: u32 = 32;

/// Maximum number of properties that can be attached to a device
pub const PROPERTIES_MAX: u32 = 256;

/// Maximum length of a string property key and value.
pub const STR_LENGTH_MAX: u32 = 255;

/// Maximum number of string properties that can be attached to a device
pub const STR_PROPERTIES_MAX: u32 = 256;

bitflags! {
    /// Bit flags for device add configuration
    #[derive(Default)]
    pub struct AddDeviceConfig: u32 {
        /// Device can be a fragment in multiple composite devices
        const ALLOW_MULTI_COMPOSITE = 1;
        /// Device should not trigger the auto-bind mechanism
        const SKIP_AUTOBIND = 4;
        /// Device should run in an isolated driver host from its children.
        const MUST_ISOLATE = 8;
    }
}

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

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

#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u8)]
pub enum SystemPowerState {
    FullyOn = 1,
    Reboot = 2,
    RebootBootloader = 3,
    RebootRecovery = 4,
    Poweroff = 5,
    Mexec = 6,
    SuspendRam = 7,
    RebootKernelInitiated = 8,
}

impl SystemPowerState {
    #[inline]
    pub fn from_primitive(prim: u8) -> Option<Self> {
        match prim {
            1 => Some(Self::FullyOn),
            2 => Some(Self::Reboot),
            3 => Some(Self::RebootBootloader),
            4 => Some(Self::RebootRecovery),
            5 => Some(Self::Poweroff),
            6 => Some(Self::Mexec),
            7 => Some(Self::SuspendRam),
            8 => Some(Self::RebootKernelInitiated),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> u8 {
        self as u8
    }

    #[deprecated = "Strict enums should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

/// This struct holds non-resource arguments for creating a new device with the
/// Coordinator.
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct AddDeviceArgs {
    /// The device name, used for debugging.
    pub name: String,
    /// The protocol id, used for binding.
    pub protocol_id: u32,
    /// The property list of the device, used for binding.
    pub property_list: DevicePropertyList,
    /// The driver path, used for debugging.
    pub driver_path: Option<String>,
    /// This should be used only for shadowed device. This will be forwarded to
    /// the shadowed device.
    pub args: Option<String>,
    pub device_add_config: AddDeviceConfig,
    pub has_init: bool,
    /// An address pointing to the DFv2 device symbol, which contains its banjo
    /// ops. This exists on every DFv1 device, but it is only used by a DFv2
    /// child.
    pub dfv2_device_symbol: u64,
}

impl fidl::Persistable for AddDeviceArgs {}

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

impl fidl::Persistable for AdministratorUnregisterSystemStorageForShutdownResponse {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct BindInstruction {
    /// bitfield that encodes the operation and execution conditions
    pub op: u32,
    /// bitfield that encodes the arguments
    pub arg: u32,
    /// bitfield that encodes debugging information
    pub debug: u32,
}

impl fidl::Persistable for BindInstruction {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct CompositeDevice {
    pub fragments: Vec<Fragment>,
    pub name: String,
}

impl fidl::Persistable for CompositeDevice {}

/// Composite device parts and properties
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct CompositeDeviceDescriptor {
    pub props: Vec<DeviceProperty>,
    pub str_props: Vec<DeviceStrProperty>,
    pub fragments: Vec<DeviceFragment>,
    pub primary_fragment_index: u32,
    pub spawn_colocated: bool,
    pub metadata: Option<Vec<DeviceMetadata>>,
}

impl fidl::Persistable for CompositeDeviceDescriptor {}

/// Composite node specification parts and properties.
#[derive(Clone, Debug, PartialEq)]
pub struct CompositeNodeSpecDescriptor {
    pub parents: Vec<fidl_fuchsia_driver_framework::ParentSpec>,
    pub metadata: Option<Vec<DeviceMetadata>>,
}

impl fidl::Persistable for CompositeNodeSpecDescriptor {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct CoordinatorAddCompositeDeviceRequest {
    pub name: String,
    pub comp_desc: CompositeDeviceDescriptor,
}

impl fidl::Persistable for CoordinatorAddCompositeDeviceRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct CoordinatorAddCompositeNodeSpecRequest {
    pub name: String,
    pub spec: CompositeNodeSpecDescriptor,
}

impl fidl::Persistable for CoordinatorAddCompositeNodeSpecRequest {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct CoordinatorAddDeviceRequest {
    pub args: AddDeviceArgs,
    pub coordinator: fidl::endpoints::ServerEnd<CoordinatorMarker>,
    pub device_controller: fidl::endpoints::ClientEnd<DeviceControllerMarker>,
    pub inspect: Option<fidl::Vmo>,
    pub outgoing_dir: Option<fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>>,
}

impl fidl::Standalone for CoordinatorAddDeviceRequest {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct CoordinatorAddMetadataRequest {
    pub key: u32,
    pub data: Option<Vec<u8>>,
}

impl fidl::Persistable for CoordinatorAddMetadataRequest {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct CoordinatorBindDeviceRequest {
    pub driver_url_suffix: Option<String>,
}

impl fidl::Persistable for CoordinatorBindDeviceRequest {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct CoordinatorConnectFidlProtocolRequest {
    pub fragment_name: Option<String>,
    pub service_name: Option<String>,
    pub protocol_name: String,
    pub server: fidl::Channel,
}

impl fidl::Standalone for CoordinatorConnectFidlProtocolRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct CoordinatorGetMetadataRequest {
    pub key: u32,
}

impl fidl::Persistable for CoordinatorGetMetadataRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct CoordinatorGetMetadataSizeRequest {
    pub key: u32,
}

impl fidl::Persistable for CoordinatorGetMetadataSizeRequest {}

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

impl fidl::Persistable for CoordinatorLoadFirmwareRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct CoordinatorScheduleRemoveRequest {
    pub unbind_self: bool,
}

impl fidl::Persistable for CoordinatorScheduleRemoveRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct CoordinatorAddDeviceResponse {
    pub local_device_id: u64,
}

impl fidl::Persistable for CoordinatorAddDeviceResponse {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct CoordinatorGetMetadataSizeResponse {
    pub size: u64,
}

impl fidl::Persistable for CoordinatorGetMetadataSizeResponse {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct CoordinatorGetMetadataResponse {
    pub data: Vec<u8>,
}

impl fidl::Persistable for CoordinatorGetMetadataResponse {}

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

impl fidl::Persistable for CoordinatorGetTopologicalPathResponse {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct CoordinatorLoadFirmwareResponse {
    pub vmo: fidl::Vmo,
    pub size: u64,
}

impl fidl::Standalone for CoordinatorLoadFirmwareResponse {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct CoordinatorScheduleUnbindChildrenResponse {
    pub has_children: bool,
}

impl fidl::Persistable for CoordinatorScheduleUnbindChildrenResponse {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DeviceControllerBindDriverRequest {
    pub driver_path: String,
    pub driver: fidl::Vmo,
    pub default_dispatcher_scheduler_role: String,
}

impl fidl::Standalone for DeviceControllerBindDriverRequest {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DeviceControllerBindDriverResponse {
    pub status: i32,
    pub test_output: Option<fidl::Channel>,
}

impl fidl::Standalone for DeviceControllerBindDriverResponse {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DeviceControllerConnectMultiplexedRequest {
    pub server: fidl::Channel,
    pub include_node: bool,
    pub include_controller: bool,
}

impl fidl::Standalone for DeviceControllerConnectMultiplexedRequest {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DeviceControllerConnectProxyRequest {
    pub shadow: fidl::Channel,
}

impl fidl::Standalone for DeviceControllerConnectProxyRequest {}

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

impl fidl::Standalone for DeviceControllerConnectToControllerRequest {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DeviceControllerConnectToDeviceProtocolRequest {
    pub server: fidl::Channel,
}

impl fidl::Standalone for DeviceControllerConnectToDeviceProtocolRequest {}

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

impl fidl::Persistable for DeviceControllerInitResponse {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct DeviceControllerResumeRequest {
    pub target_system_state: u32,
}

impl fidl::Persistable for DeviceControllerResumeRequest {}

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

impl fidl::Persistable for DeviceControllerResumeResponse {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct DeviceControllerSuspendRequest {
    pub flags: u32,
}

impl fidl::Persistable for DeviceControllerSuspendRequest {}

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

impl fidl::Persistable for DeviceControllerSuspendResponse {}

/// A piece of a composite device
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DeviceFragment {
    pub name: String,
    pub parts: Vec<DeviceFragmentPart>,
}

impl fidl::Persistable for DeviceFragment {}

/// A part of a description of a DeviceFragment
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DeviceFragmentPart {
    pub match_program: Vec<BindInstruction>,
}

impl fidl::Persistable for DeviceFragmentPart {}

/// Metadata that can be added to a device
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DeviceMetadata {
    pub key: u32,
    pub data: Vec<u8>,
}

impl fidl::Persistable for DeviceMetadata {}

/// This has the same structure as zx_device_prop_t.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct DeviceProperty {
    pub id: u16,
    pub reserved: u16,
    pub value: u32,
}

impl fidl::Persistable for DeviceProperty {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DevicePropertyList {
    pub props: Vec<DeviceProperty>,
    pub str_props: Vec<DeviceStrProperty>,
}

impl fidl::Persistable for DevicePropertyList {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DeviceStrProperty {
    pub key: String,
    pub value: PropertyValue,
}

impl fidl::Persistable for DeviceStrProperty {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DriverHostControllerCreateDeviceRequest {
    pub coordinator: fidl::endpoints::ClientEnd<CoordinatorMarker>,
    pub device_controller: fidl::endpoints::ServerEnd<DeviceControllerMarker>,
    pub type_: DeviceType,
    pub local_device_id: u64,
}

impl fidl::Standalone for DriverHostControllerCreateDeviceRequest {}

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

impl fidl::Persistable for DriverHostControllerCreateDeviceResponse {}

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

impl fidl::Persistable for DriverHostControllerRestartResponse {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct FidlProxyDevice {
    /// If this is present this represents an incoming namespace directory that the
    /// device can use to access FIDL protocols from its parent.
    pub incoming_dir: Option<fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>>,
}

impl fidl::Standalone for FidlProxyDevice {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct Fragment {
    pub name: String,
    pub id: u64,
}

impl fidl::Persistable for Fragment {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ProxyDevice {
    pub driver_path: String,
    pub driver: fidl::Vmo,
    pub parent_proxy: fidl::Channel,
}

impl fidl::Standalone for ProxyDevice {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct StubDevice {
    pub protocol_id: u32,
}

impl fidl::Persistable for StubDevice {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct SystemStateTransitionGetTerminationSystemStateResponse {
    pub state: SystemPowerState,
}

impl fidl::Persistable for SystemStateTransitionGetTerminationSystemStateResponse {}

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

impl fidl::Standalone for SystemStateTransitionGetMexecZbisResponse {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum DeviceType {
    /// The device has no parent to communicate with and no driver to load.
    Stub(StubDevice),
    /// The device acts as a proxy for its parent and talks to it via its
    /// proxy channel.
    Proxy(ProxyDevice),
    /// This device is a proxy for its parent which lives in another driver host.
    /// The parent exposes FIDL protocols in its outgoing directory, which have
    /// been routed to this device.
    FidlProxy(FidlProxyDevice),
    /// The device is a composite device with several parents, referred to as
    /// fragments. The device aggregates all parent devices together. The order of the
    /// fragments will match the original composite creation request.
    Composite(CompositeDevice),
}

impl DeviceType {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::Stub(_) => 1,
            Self::Proxy(_) => 2,
            Self::FidlProxy(_) => 3,
            Self::Composite(_) => 4,
        }
    }

    #[deprecated = "Strict unions should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

impl fidl::Standalone for DeviceType {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum PropertyValue {
    IntValue(u32),
    StrValue(String),
    BoolValue(bool),
    EnumValue(String),
}

impl PropertyValue {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::IntValue(_) => 1,
            Self::StrValue(_) => 2,
            Self::BoolValue(_) => 3,
            Self::EnumValue(_) => 4,
        }
    }

    #[deprecated = "Strict unions should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

impl fidl::Persistable for PropertyValue {}

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

impl fidl::endpoints::ProtocolMarker for AdministratorMarker {
    type Proxy = AdministratorProxy;
    type RequestStream = AdministratorRequestStream;
    const DEBUG_NAME: &'static str = "fuchsia.device.manager.Administrator";
}
impl fidl::endpoints::DiscoverableProtocolMarker for AdministratorMarker {}

pub trait AdministratorProxyInterface: Send + Sync {
    type UnregisterSystemStorageForShutdownResponseFut: std::future::Future<Output = Result<i32, fidl::Error>>
        + Send;
    fn r#unregister_system_storage_for_shutdown(
        &self,
    ) -> Self::UnregisterSystemStorageForShutdownResponseFut;
    fn r#suspend_without_exit(&self) -> Result<(), fidl::Error>;
}

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

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

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

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

    /// This is a temporary API until DriverManager can ensure that base drivers
    /// will be shut down automatically before fshost exits. This will happen
    /// once drivers-as-components is implemented.
    /// In the meantime, this API should only be called by fshost, and it must
    /// be called before fshost exits. This function iterates over the devices
    /// and suspends any device whose driver lives in storage. This API must be
    /// called by fshost before it shuts down. Otherwise the devices that live
    /// in storage may page fault as it access memory that should be provided by
    /// the exited fshost. This function will not return until the devices are
    /// suspended. If there are no devices that live in storage, this function
    /// will immediatetly return.
    pub fn r#unregister_system_storage_for_shutdown(
        &self,
        ___deadline: zx::Time,
    ) -> Result<i32, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            AdministratorUnregisterSystemStorageForShutdownResponse,
        >(
            (),
            0x3a423df51409d155,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.status)
    }

    /// Tell DriverManager to go through the suspend process, but don't exit
    /// afterwards. This is used in tests to check that suspend works correctly.
    pub fn r#suspend_without_exit(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x2607cb5dff16a5f7,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::Proxy for AdministratorProxy {
    type Protocol = AdministratorMarker;

    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 AdministratorProxy {
    /// Create a new Proxy for fuchsia.device.manager/Administrator.
    pub fn new(channel: fidl::AsyncChannel) -> Self {
        let protocol_name = <AdministratorMarker 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) -> AdministratorEventStream {
        AdministratorEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// This is a temporary API until DriverManager can ensure that base drivers
    /// will be shut down automatically before fshost exits. This will happen
    /// once drivers-as-components is implemented.
    /// In the meantime, this API should only be called by fshost, and it must
    /// be called before fshost exits. This function iterates over the devices
    /// and suspends any device whose driver lives in storage. This API must be
    /// called by fshost before it shuts down. Otherwise the devices that live
    /// in storage may page fault as it access memory that should be provided by
    /// the exited fshost. This function will not return until the devices are
    /// suspended. If there are no devices that live in storage, this function
    /// will immediatetly return.
    pub fn r#unregister_system_storage_for_shutdown(&self) -> fidl::client::QueryResponseFut<i32> {
        AdministratorProxyInterface::r#unregister_system_storage_for_shutdown(self)
    }

    /// Tell DriverManager to go through the suspend process, but don't exit
    /// afterwards. This is used in tests to check that suspend works correctly.
    pub fn r#suspend_without_exit(&self) -> Result<(), fidl::Error> {
        AdministratorProxyInterface::r#suspend_without_exit(self)
    }
}

impl AdministratorProxyInterface for AdministratorProxy {
    type UnregisterSystemStorageForShutdownResponseFut = fidl::client::QueryResponseFut<i32>;
    fn r#unregister_system_storage_for_shutdown(
        &self,
    ) -> Self::UnregisterSystemStorageForShutdownResponseFut {
        fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                AdministratorUnregisterSystemStorageForShutdownResponse,
                0x3a423df51409d155,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, i32>(
            (),
            0x3a423df51409d155,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.device.manager/Administrator.
pub struct AdministratorRequestStream {
    inner: std::sync::Arc<fidl::ServeInner>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for AdministratorRequestStream {
    type Protocol = AdministratorMarker;
    type ControlHandle = AdministratorControlHandle;

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

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

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

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

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

            std::task::Poll::Ready(Some(match header.ordinal {
                0x3a423df51409d155 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
                    fidl::encoding::Decoder::decode_into::<fidl::encoding::EmptyPayload>(
                        &header,
                        _body_bytes,
                        handles,
                        &mut req,
                    )?;
                    let control_handle = AdministratorControlHandle { inner: this.inner.clone() };
                    Ok(AdministratorRequest::UnregisterSystemStorageForShutdown {
                        responder: AdministratorUnregisterSystemStorageForShutdownResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x2607cb5dff16a5f7 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
                    fidl::encoding::Decoder::decode_into::<fidl::encoding::EmptyPayload>(
                        &header,
                        _body_bytes,
                        handles,
                        &mut req,
                    )?;
                    let control_handle = AdministratorControlHandle { inner: this.inner.clone() };
                    Ok(AdministratorRequest::SuspendWithoutExit { control_handle })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name:
                        <AdministratorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
        })
    }
}

/// Provides administration services for the device manager service and the device tree it controls.
#[derive(Debug)]
pub enum AdministratorRequest {
    /// This is a temporary API until DriverManager can ensure that base drivers
    /// will be shut down automatically before fshost exits. This will happen
    /// once drivers-as-components is implemented.
    /// In the meantime, this API should only be called by fshost, and it must
    /// be called before fshost exits. This function iterates over the devices
    /// and suspends any device whose driver lives in storage. This API must be
    /// called by fshost before it shuts down. Otherwise the devices that live
    /// in storage may page fault as it access memory that should be provided by
    /// the exited fshost. This function will not return until the devices are
    /// suspended. If there are no devices that live in storage, this function
    /// will immediatetly return.
    UnregisterSystemStorageForShutdown {
        responder: AdministratorUnregisterSystemStorageForShutdownResponder,
    },
    /// Tell DriverManager to go through the suspend process, but don't exit
    /// afterwards. This is used in tests to check that suspend works correctly.
    SuspendWithoutExit { control_handle: AdministratorControlHandle },
}

impl AdministratorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_unregister_system_storage_for_shutdown(
        self,
    ) -> Option<(AdministratorUnregisterSystemStorageForShutdownResponder)> {
        if let AdministratorRequest::UnregisterSystemStorageForShutdown { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_suspend_without_exit(self) -> Option<(AdministratorControlHandle)> {
        if let AdministratorRequest::SuspendWithoutExit { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            AdministratorRequest::UnregisterSystemStorageForShutdown { .. } => {
                "unregister_system_storage_for_shutdown"
            }
            AdministratorRequest::SuspendWithoutExit { .. } => "suspend_without_exit",
        }
    }
}

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

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

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

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }

    fn on_closed<'a>(&'a self) -> fidl::OnSignals<'a> {
        self.inner.channel().on_closed()
    }
}

impl AdministratorControlHandle {}

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for CoordinatorMarker {
    type Proxy = CoordinatorProxy;
    type RequestStream = CoordinatorRequestStream;
    const DEBUG_NAME: &'static str = "(anonymous) Coordinator";
}
pub type CoordinatorAddDeviceResult = Result<u64, i32>;
pub type CoordinatorScheduleUnbindChildrenResult = Result<bool, i32>;
pub type CoordinatorBindDeviceResult = Result<(), i32>;
pub type CoordinatorGetTopologicalPathResult = Result<String, i32>;
pub type CoordinatorLoadFirmwareResult = Result<(fidl::Vmo, u64), i32>;
pub type CoordinatorGetMetadataResult = Result<Vec<u8>, i32>;
pub type CoordinatorGetMetadataSizeResult = Result<u64, i32>;
pub type CoordinatorAddMetadataResult = Result<(), i32>;
pub type CoordinatorAddCompositeDeviceResult = Result<(), i32>;
pub type CoordinatorAddCompositeNodeSpecResult = Result<(), i32>;
pub type CoordinatorConnectFidlProtocolResult = Result<(), i32>;

pub trait CoordinatorProxyInterface: Send + Sync {
    type AddDeviceResponseFut: std::future::Future<Output = Result<CoordinatorAddDeviceResult, fidl::Error>>
        + Send;
    fn r#add_device(
        &self,
        args: &AddDeviceArgs,
        coordinator: fidl::endpoints::ServerEnd<CoordinatorMarker>,
        device_controller: fidl::endpoints::ClientEnd<DeviceControllerMarker>,
        inspect: Option<fidl::Vmo>,
        outgoing_dir: Option<fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>>,
    ) -> Self::AddDeviceResponseFut;
    fn r#schedule_remove(&self, unbind_self: bool) -> Result<(), fidl::Error>;
    type ScheduleUnbindChildrenResponseFut: std::future::Future<Output = Result<CoordinatorScheduleUnbindChildrenResult, fidl::Error>>
        + Send;
    fn r#schedule_unbind_children(&self) -> Self::ScheduleUnbindChildrenResponseFut;
    type BindDeviceResponseFut: std::future::Future<Output = Result<CoordinatorBindDeviceResult, fidl::Error>>
        + Send;
    fn r#bind_device(&self, driver_url_suffix: Option<&str>) -> Self::BindDeviceResponseFut;
    type GetTopologicalPathResponseFut: std::future::Future<Output = Result<CoordinatorGetTopologicalPathResult, fidl::Error>>
        + Send;
    fn r#get_topological_path(&self) -> Self::GetTopologicalPathResponseFut;
    type LoadFirmwareResponseFut: std::future::Future<Output = Result<CoordinatorLoadFirmwareResult, fidl::Error>>
        + Send;
    fn r#load_firmware(&self, driver_path: &str, fw_path: &str) -> Self::LoadFirmwareResponseFut;
    type GetMetadataResponseFut: std::future::Future<Output = Result<CoordinatorGetMetadataResult, fidl::Error>>
        + Send;
    fn r#get_metadata(&self, key: u32) -> Self::GetMetadataResponseFut;
    type GetMetadataSizeResponseFut: std::future::Future<Output = Result<CoordinatorGetMetadataSizeResult, fidl::Error>>
        + Send;
    fn r#get_metadata_size(&self, key: u32) -> Self::GetMetadataSizeResponseFut;
    type AddMetadataResponseFut: std::future::Future<Output = Result<CoordinatorAddMetadataResult, fidl::Error>>
        + Send;
    fn r#add_metadata(&self, key: u32, data: Option<&[u8]>) -> Self::AddMetadataResponseFut;
    type AddCompositeDeviceResponseFut: std::future::Future<Output = Result<CoordinatorAddCompositeDeviceResult, fidl::Error>>
        + Send;
    fn r#add_composite_device(
        &self,
        name: &str,
        comp_desc: &CompositeDeviceDescriptor,
    ) -> Self::AddCompositeDeviceResponseFut;
    type AddCompositeNodeSpecResponseFut: std::future::Future<Output = Result<CoordinatorAddCompositeNodeSpecResult, fidl::Error>>
        + Send;
    fn r#add_composite_node_spec(
        &self,
        name: &str,
        spec: &CompositeNodeSpecDescriptor,
    ) -> Self::AddCompositeNodeSpecResponseFut;
    type ConnectFidlProtocolResponseFut: std::future::Future<Output = Result<CoordinatorConnectFidlProtocolResult, fidl::Error>>
        + Send;
    fn r#connect_fidl_protocol(
        &self,
        fragment_name: Option<&str>,
        service_name: Option<&str>,
        protocol_name: &str,
        server: fidl::Channel,
    ) -> Self::ConnectFidlProtocolResponseFut;
}

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

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

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

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

    /// Record the addition of a new device that can be communicated with via `device_controller`.
    /// On success, the returned `local_device_id` is the identifier assigned by devmgr.
    pub fn r#add_device(
        &self,
        mut args: &AddDeviceArgs,
        mut coordinator: fidl::endpoints::ServerEnd<CoordinatorMarker>,
        mut device_controller: fidl::endpoints::ClientEnd<DeviceControllerMarker>,
        mut inspect: Option<fidl::Vmo>,
        mut outgoing_dir: Option<fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>>,
        ___deadline: zx::Time,
    ) -> Result<CoordinatorAddDeviceResult, fidl::Error> {
        let _response = self.client.send_query::<
            CoordinatorAddDeviceRequest,
            fidl::encoding::ResultType<CoordinatorAddDeviceResponse, i32>,
        >(
            (args, coordinator, device_controller, inspect, outgoing_dir,),
            0x2790f5d086adbf8f,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.local_device_id))
    }

    /// Requests the devcoordinator schedule the removal of this device,
    /// and the unbinding of its children.
    /// If `unbind_self` is true, the unbind hook for this device will also be called.
    pub fn r#schedule_remove(&self, mut unbind_self: bool) -> Result<(), fidl::Error> {
        self.client.send::<CoordinatorScheduleRemoveRequest>(
            (unbind_self,),
            0x1bdeb4d5d1f4d21e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Requests the devcoordinator schedule the unbinding of this device's children.
    /// If the device has no children, no request will be sent, and `has_children` will be false.
    pub fn r#schedule_unbind_children(
        &self,
        ___deadline: zx::Time,
    ) -> Result<CoordinatorScheduleUnbindChildrenResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                CoordinatorScheduleUnbindChildrenResponse,
                i32,
            >>(
                (),
                0x658a6d68027b7139,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.has_children))
    }

    /// Attempt to bind a driver against this device.
    /// + request `driver_url_suffix` only driver's that match this URL suffix will try to bind to
    ///           the device (e.g: "fvm.cm").
    ///           If this is null, the API will autobind.
    /// * error `ZX_ERR_ALREADY_BOUND` if the device is already bound.
    /// * error `ZX_ERR_NOT_FOUND` no drivers were found.
    pub fn r#bind_device(
        &self,
        mut driver_url_suffix: Option<&str>,
        ___deadline: zx::Time,
    ) -> Result<CoordinatorBindDeviceResult, fidl::Error> {
        let _response = self.client.send_query::<
            CoordinatorBindDeviceRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (driver_url_suffix,),
            0x274db0bd334639ca,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Returns the topological path of this device.
    pub fn r#get_topological_path(
        &self,
        ___deadline: zx::Time,
    ) -> Result<CoordinatorGetTopologicalPathResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<CoordinatorGetTopologicalPathResponse, i32>,
        >(
            (),
            0x319ccef1252fd6bf,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.path))
    }

    /// Requests that the firmware at the given path be loaded and returned.
    pub fn r#load_firmware(
        &self,
        mut driver_path: &str,
        mut fw_path: &str,
        ___deadline: zx::Time,
    ) -> Result<CoordinatorLoadFirmwareResult, fidl::Error> {
        let _response = self.client.send_query::<
            CoordinatorLoadFirmwareRequest,
            fidl::encoding::ResultType<CoordinatorLoadFirmwareResponse, i32>,
        >(
            (driver_path, fw_path,),
            0x5c24700e7a9815bd,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| (x.vmo, x.size)))
    }

    /// Retrieve the metadata blob associated with this device and the given key.
    pub fn r#get_metadata(
        &self,
        mut key: u32,
        ___deadline: zx::Time,
    ) -> Result<CoordinatorGetMetadataResult, fidl::Error> {
        let _response = self.client.send_query::<
            CoordinatorGetMetadataRequest,
            fidl::encoding::ResultType<CoordinatorGetMetadataResponse, i32>,
        >(
            (key,),
            0x34abe1351145bf3f,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.data))
    }

    /// Retrieve the metadata size associated with this device and the given key.
    pub fn r#get_metadata_size(
        &self,
        mut key: u32,
        ___deadline: zx::Time,
    ) -> Result<CoordinatorGetMetadataSizeResult, fidl::Error> {
        let _response = self.client.send_query::<
            CoordinatorGetMetadataSizeRequest,
            fidl::encoding::ResultType<CoordinatorGetMetadataSizeResponse, i32>,
        >(
            (key,),
            0x290826b5b7483d61,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.size))
    }

    /// Add metadata blob associated with this device and the given key.
    /// If the same key is specified multiple times, the new data will be
    /// ignored in favor of the data from first call with the specified key.
    pub fn r#add_metadata(
        &self,
        mut key: u32,
        mut data: Option<&[u8]>,
        ___deadline: zx::Time,
    ) -> Result<CoordinatorAddMetadataResult, fidl::Error> {
        let _response = self.client.send_query::<
            CoordinatorAddMetadataRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (key, data,),
            0x7acb84ea4eb23c94,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Adds the given composite device.  This causes the driver manager to try to match the
    /// fragments against the existing device tree, and to monitor all new device additions
    /// in order to find the fragments as they are created.
    pub fn r#add_composite_device(
        &self,
        mut name: &str,
        mut comp_desc: &CompositeDeviceDescriptor,
        ___deadline: zx::Time,
    ) -> Result<CoordinatorAddCompositeDeviceResult, fidl::Error> {
        let _response = self.client.send_query::<
            CoordinatorAddCompositeDeviceRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (name, comp_desc,),
            0x1610b2d89769d054,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Adds the given composite node spec. This causes the driver manager to add the spec to
    /// the driver index, and then try to match the parents against the node topology.
    /// All device additions will be monitored to see if they matched to the remaining
    /// unbound nodes.
    pub fn r#add_composite_node_spec(
        &self,
        mut name: &str,
        mut spec: &CompositeNodeSpecDescriptor,
        ___deadline: zx::Time,
    ) -> Result<CoordinatorAddCompositeNodeSpecResult, fidl::Error> {
        let _response = self.client.send_query::<
            CoordinatorAddCompositeNodeSpecRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (name, spec,),
            0x1ecc89bad1ab5c75,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Connects the given FIDL protocol inside of a FIDL service. Connection is completed
    /// asynchronously due to pipelining. Returning `ZX_OK` does not imply the service exists. A
    /// two way call to the service via the retained client end of the channel pair must be issued
    /// in order to ascertain whether the connection has been successfully established.
    /// + |fragment_name| should be specified if the parent is a composite node.
    /// + |service_name| should be specified if attempting to connect to a service. This will be
    ///   mandatory in the future: http://fxbug.dev/107155.
    /// * error Reports `ZX_ERR_UNAVAILABLE` if the parent (or fragment) does not have an outgoing
    ///   directory.
    /// * error Reports `ZX_ERR_NOT_FOUND` if |fragment_name| is not the name of a parent.
    /// * error Reports `ZX_ERR_NOT_SUPPORTED` if |fragment_name| is specified by the device is not
    ///   a composite node
    pub fn r#connect_fidl_protocol(
        &self,
        mut fragment_name: Option<&str>,
        mut service_name: Option<&str>,
        mut protocol_name: &str,
        mut server: fidl::Channel,
        ___deadline: zx::Time,
    ) -> Result<CoordinatorConnectFidlProtocolResult, fidl::Error> {
        let _response = self.client.send_query::<
            CoordinatorConnectFidlProtocolRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (fragment_name, service_name, protocol_name, server,),
            0x7c9861ff4ed7fc75,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

impl fidl::endpoints::Proxy for CoordinatorProxy {
    type Protocol = CoordinatorMarker;

    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 CoordinatorProxy {
    /// Create a new Proxy for fuchsia.device.manager/Coordinator.
    pub fn new(channel: fidl::AsyncChannel) -> Self {
        let protocol_name = <CoordinatorMarker 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) -> CoordinatorEventStream {
        CoordinatorEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Record the addition of a new device that can be communicated with via `device_controller`.
    /// On success, the returned `local_device_id` is the identifier assigned by devmgr.
    pub fn r#add_device(
        &self,
        mut args: &AddDeviceArgs,
        mut coordinator: fidl::endpoints::ServerEnd<CoordinatorMarker>,
        mut device_controller: fidl::endpoints::ClientEnd<DeviceControllerMarker>,
        mut inspect: Option<fidl::Vmo>,
        mut outgoing_dir: Option<fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>>,
    ) -> fidl::client::QueryResponseFut<CoordinatorAddDeviceResult> {
        CoordinatorProxyInterface::r#add_device(
            self,
            args,
            coordinator,
            device_controller,
            inspect,
            outgoing_dir,
        )
    }

    /// Requests the devcoordinator schedule the removal of this device,
    /// and the unbinding of its children.
    /// If `unbind_self` is true, the unbind hook for this device will also be called.
    pub fn r#schedule_remove(&self, mut unbind_self: bool) -> Result<(), fidl::Error> {
        CoordinatorProxyInterface::r#schedule_remove(self, unbind_self)
    }

    /// Requests the devcoordinator schedule the unbinding of this device's children.
    /// If the device has no children, no request will be sent, and `has_children` will be false.
    pub fn r#schedule_unbind_children(
        &self,
    ) -> fidl::client::QueryResponseFut<CoordinatorScheduleUnbindChildrenResult> {
        CoordinatorProxyInterface::r#schedule_unbind_children(self)
    }

    /// Attempt to bind a driver against this device.
    /// + request `driver_url_suffix` only driver's that match this URL suffix will try to bind to
    ///           the device (e.g: "fvm.cm").
    ///           If this is null, the API will autobind.
    /// * error `ZX_ERR_ALREADY_BOUND` if the device is already bound.
    /// * error `ZX_ERR_NOT_FOUND` no drivers were found.
    pub fn r#bind_device(
        &self,
        mut driver_url_suffix: Option<&str>,
    ) -> fidl::client::QueryResponseFut<CoordinatorBindDeviceResult> {
        CoordinatorProxyInterface::r#bind_device(self, driver_url_suffix)
    }

    /// Returns the topological path of this device.
    pub fn r#get_topological_path(
        &self,
    ) -> fidl::client::QueryResponseFut<CoordinatorGetTopologicalPathResult> {
        CoordinatorProxyInterface::r#get_topological_path(self)
    }

    /// Requests that the firmware at the given path be loaded and returned.
    pub fn r#load_firmware(
        &self,
        mut driver_path: &str,
        mut fw_path: &str,
    ) -> fidl::client::QueryResponseFut<CoordinatorLoadFirmwareResult> {
        CoordinatorProxyInterface::r#load_firmware(self, driver_path, fw_path)
    }

    /// Retrieve the metadata blob associated with this device and the given key.
    pub fn r#get_metadata(
        &self,
        mut key: u32,
    ) -> fidl::client::QueryResponseFut<CoordinatorGetMetadataResult> {
        CoordinatorProxyInterface::r#get_metadata(self, key)
    }

    /// Retrieve the metadata size associated with this device and the given key.
    pub fn r#get_metadata_size(
        &self,
        mut key: u32,
    ) -> fidl::client::QueryResponseFut<CoordinatorGetMetadataSizeResult> {
        CoordinatorProxyInterface::r#get_metadata_size(self, key)
    }

    /// Add metadata blob associated with this device and the given key.
    /// If the same key is specified multiple times, the new data will be
    /// ignored in favor of the data from first call with the specified key.
    pub fn r#add_metadata(
        &self,
        mut key: u32,
        mut data: Option<&[u8]>,
    ) -> fidl::client::QueryResponseFut<CoordinatorAddMetadataResult> {
        CoordinatorProxyInterface::r#add_metadata(self, key, data)
    }

    /// Adds the given composite device.  This causes the driver manager to try to match the
    /// fragments against the existing device tree, and to monitor all new device additions
    /// in order to find the fragments as they are created.
    pub fn r#add_composite_device(
        &self,
        mut name: &str,
        mut comp_desc: &CompositeDeviceDescriptor,
    ) -> fidl::client::QueryResponseFut<CoordinatorAddCompositeDeviceResult> {
        CoordinatorProxyInterface::r#add_composite_device(self, name, comp_desc)
    }

    /// Adds the given composite node spec. This causes the driver manager to add the spec to
    /// the driver index, and then try to match the parents against the node topology.
    /// All device additions will be monitored to see if they matched to the remaining
    /// unbound nodes.
    pub fn r#add_composite_node_spec(
        &self,
        mut name: &str,
        mut spec: &CompositeNodeSpecDescriptor,
    ) -> fidl::client::QueryResponseFut<CoordinatorAddCompositeNodeSpecResult> {
        CoordinatorProxyInterface::r#add_composite_node_spec(self, name, spec)
    }

    /// Connects the given FIDL protocol inside of a FIDL service. Connection is completed
    /// asynchronously due to pipelining. Returning `ZX_OK` does not imply the service exists. A
    /// two way call to the service via the retained client end of the channel pair must be issued
    /// in order to ascertain whether the connection has been successfully established.
    /// + |fragment_name| should be specified if the parent is a composite node.
    /// + |service_name| should be specified if attempting to connect to a service. This will be
    ///   mandatory in the future: http://fxbug.dev/107155.
    /// * error Reports `ZX_ERR_UNAVAILABLE` if the parent (or fragment) does not have an outgoing
    ///   directory.
    /// * error Reports `ZX_ERR_NOT_FOUND` if |fragment_name| is not the name of a parent.
    /// * error Reports `ZX_ERR_NOT_SUPPORTED` if |fragment_name| is specified by the device is not
    ///   a composite node
    pub fn r#connect_fidl_protocol(
        &self,
        mut fragment_name: Option<&str>,
        mut service_name: Option<&str>,
        mut protocol_name: &str,
        mut server: fidl::Channel,
    ) -> fidl::client::QueryResponseFut<CoordinatorConnectFidlProtocolResult> {
        CoordinatorProxyInterface::r#connect_fidl_protocol(
            self,
            fragment_name,
            service_name,
            protocol_name,
            server,
        )
    }
}

impl CoordinatorProxyInterface for CoordinatorProxy {
    type AddDeviceResponseFut = fidl::client::QueryResponseFut<CoordinatorAddDeviceResult>;
    fn r#add_device(
        &self,
        mut args: &AddDeviceArgs,
        mut coordinator: fidl::endpoints::ServerEnd<CoordinatorMarker>,
        mut device_controller: fidl::endpoints::ClientEnd<DeviceControllerMarker>,
        mut inspect: Option<fidl::Vmo>,
        mut outgoing_dir: Option<fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>>,
    ) -> Self::AddDeviceResponseFut {
        fn _decode(
            mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
        ) -> Result<CoordinatorAddDeviceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<CoordinatorAddDeviceResponse, i32>,
                0x2790f5d086adbf8f,
            >(_buf?)?;
            Ok(_response.map(|x| x.local_device_id))
        }
        self.client
            .send_query_and_decode::<CoordinatorAddDeviceRequest, CoordinatorAddDeviceResult>(
                (args, coordinator, device_controller, inspect, outgoing_dir),
                0x2790f5d086adbf8f,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    fn r#schedule_remove(&self, mut unbind_self: bool) -> Result<(), fidl::Error> {
        self.client.send::<CoordinatorScheduleRemoveRequest>(
            (unbind_self,),
            0x1bdeb4d5d1f4d21e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type ScheduleUnbindChildrenResponseFut =
        fidl::client::QueryResponseFut<CoordinatorScheduleUnbindChildrenResult>;
    fn r#schedule_unbind_children(&self) -> Self::ScheduleUnbindChildrenResponseFut {
        fn _decode(
            mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
        ) -> Result<CoordinatorScheduleUnbindChildrenResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<CoordinatorScheduleUnbindChildrenResponse, i32>,
                0x658a6d68027b7139,
            >(_buf?)?;
            Ok(_response.map(|x| x.has_children))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            CoordinatorScheduleUnbindChildrenResult,
        >(
            (),
            0x658a6d68027b7139,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type BindDeviceResponseFut = fidl::client::QueryResponseFut<CoordinatorBindDeviceResult>;
    fn r#bind_device(&self, mut driver_url_suffix: Option<&str>) -> Self::BindDeviceResponseFut {
        fn _decode(
            mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
        ) -> Result<CoordinatorBindDeviceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                0x274db0bd334639ca,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<CoordinatorBindDeviceRequest, CoordinatorBindDeviceResult>(
                (driver_url_suffix,),
                0x274db0bd334639ca,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetTopologicalPathResponseFut =
        fidl::client::QueryResponseFut<CoordinatorGetTopologicalPathResult>;
    fn r#get_topological_path(&self) -> Self::GetTopologicalPathResponseFut {
        fn _decode(
            mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
        ) -> Result<CoordinatorGetTopologicalPathResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<CoordinatorGetTopologicalPathResponse, i32>,
                0x319ccef1252fd6bf,
            >(_buf?)?;
            Ok(_response.map(|x| x.path))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            CoordinatorGetTopologicalPathResult,
        >(
            (),
            0x319ccef1252fd6bf,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type LoadFirmwareResponseFut = fidl::client::QueryResponseFut<CoordinatorLoadFirmwareResult>;
    fn r#load_firmware(
        &self,
        mut driver_path: &str,
        mut fw_path: &str,
    ) -> Self::LoadFirmwareResponseFut {
        fn _decode(
            mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
        ) -> Result<CoordinatorLoadFirmwareResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<CoordinatorLoadFirmwareResponse, i32>,
                0x5c24700e7a9815bd,
            >(_buf?)?;
            Ok(_response.map(|x| (x.vmo, x.size)))
        }
        self.client
            .send_query_and_decode::<CoordinatorLoadFirmwareRequest, CoordinatorLoadFirmwareResult>(
                (driver_path, fw_path),
                0x5c24700e7a9815bd,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetMetadataResponseFut = fidl::client::QueryResponseFut<CoordinatorGetMetadataResult>;
    fn r#get_metadata(&self, mut key: u32) -> Self::GetMetadataResponseFut {
        fn _decode(
            mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
        ) -> Result<CoordinatorGetMetadataResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<CoordinatorGetMetadataResponse, i32>,
                0x34abe1351145bf3f,
            >(_buf?)?;
            Ok(_response.map(|x| x.data))
        }
        self.client
            .send_query_and_decode::<CoordinatorGetMetadataRequest, CoordinatorGetMetadataResult>(
                (key,),
                0x34abe1351145bf3f,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetMetadataSizeResponseFut =
        fidl::client::QueryResponseFut<CoordinatorGetMetadataSizeResult>;
    fn r#get_metadata_size(&self, mut key: u32) -> Self::GetMetadataSizeResponseFut {
        fn _decode(
            mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
        ) -> Result<CoordinatorGetMetadataSizeResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<CoordinatorGetMetadataSizeResponse, i32>,
                0x290826b5b7483d61,
            >(_buf?)?;
            Ok(_response.map(|x| x.size))
        }
        self.client.send_query_and_decode::<
            CoordinatorGetMetadataSizeRequest,
            CoordinatorGetMetadataSizeResult,
        >(
            (key,),
            0x290826b5b7483d61,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type AddMetadataResponseFut = fidl::client::QueryResponseFut<CoordinatorAddMetadataResult>;
    fn r#add_metadata(
        &self,
        mut key: u32,
        mut data: Option<&[u8]>,
    ) -> Self::AddMetadataResponseFut {
        fn _decode(
            mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
        ) -> Result<CoordinatorAddMetadataResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                0x7acb84ea4eb23c94,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<CoordinatorAddMetadataRequest, CoordinatorAddMetadataResult>(
                (key, data),
                0x7acb84ea4eb23c94,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type AddCompositeDeviceResponseFut =
        fidl::client::QueryResponseFut<CoordinatorAddCompositeDeviceResult>;
    fn r#add_composite_device(
        &self,
        mut name: &str,
        mut comp_desc: &CompositeDeviceDescriptor,
    ) -> Self::AddCompositeDeviceResponseFut {
        fn _decode(
            mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
        ) -> Result<CoordinatorAddCompositeDeviceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                0x1610b2d89769d054,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            CoordinatorAddCompositeDeviceRequest,
            CoordinatorAddCompositeDeviceResult,
        >(
            (name, comp_desc,),
            0x1610b2d89769d054,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type AddCompositeNodeSpecResponseFut =
        fidl::client::QueryResponseFut<CoordinatorAddCompositeNodeSpecResult>;
    fn r#add_composite_node_spec(
        &self,
        mut name: &str,
        mut spec: &CompositeNodeSpecDescriptor,
    ) -> Self::AddCompositeNodeSpecResponseFut {
        fn _decode(
            mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
        ) -> Result<CoordinatorAddCompositeNodeSpecResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                0x1ecc89bad1ab5c75,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            CoordinatorAddCompositeNodeSpecRequest,
            CoordinatorAddCompositeNodeSpecResult,
        >(
            (name, spec,),
            0x1ecc89bad1ab5c75,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ConnectFidlProtocolResponseFut =
        fidl::client::QueryResponseFut<CoordinatorConnectFidlProtocolResult>;
    fn r#connect_fidl_protocol(
        &self,
        mut fragment_name: Option<&str>,
        mut service_name: Option<&str>,
        mut protocol_name: &str,
        mut server: fidl::Channel,
    ) -> Self::ConnectFidlProtocolResponseFut {
        fn _decode(
            mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
        ) -> Result<CoordinatorConnectFidlProtocolResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                0x7c9861ff4ed7fc75,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            CoordinatorConnectFidlProtocolRequest,
            CoordinatorConnectFidlProtocolResult,
        >(
            (fragment_name, service_name, protocol_name, server,),
            0x7c9861ff4ed7fc75,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.device.manager/Coordinator.
pub struct CoordinatorRequestStream {
    inner: std::sync::Arc<fidl::ServeInner>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for CoordinatorRequestStream {
    type Protocol = CoordinatorMarker;
    type ControlHandle = CoordinatorControlHandle;

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

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

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

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

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

            std::task::Poll::Ready(Some(match header.ordinal {
                0x2790f5d086adbf8f => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(CoordinatorAddDeviceRequest);
                    fidl::encoding::Decoder::decode_into::<CoordinatorAddDeviceRequest>(
                        &header,
                        _body_bytes,
                        handles,
                        &mut req,
                    )?;
                    let control_handle = CoordinatorControlHandle { inner: this.inner.clone() };
                    Ok(CoordinatorRequest::AddDevice {
                        args: req.args,
                        coordinator: req.coordinator,
                        device_controller: req.device_controller,
                        inspect: req.inspect,
                        outgoing_dir: req.outgoing_dir,

                        responder: CoordinatorAddDeviceResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x1bdeb4d5d1f4d21e => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(CoordinatorScheduleRemoveRequest);
                    fidl::encoding::Decoder::decode_into::<CoordinatorScheduleRemoveRequest>(
                        &header,
                        _body_bytes,
                        handles,
                        &mut req,
                    )?;
                    let control_handle = CoordinatorControlHandle { inner: this.inner.clone() };
                    Ok(CoordinatorRequest::ScheduleRemove {
                        unbind_self: req.unbind_self,

                        control_handle,
                    })
                }
                0x658a6d68027b7139 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
                    fidl::encoding::Decoder::decode_into::<fidl::encoding::EmptyPayload>(
                        &header,
                        _body_bytes,
                        handles,
                        &mut req,
                    )?;
                    let control_handle = CoordinatorControlHandle { inner: this.inner.clone() };
                    Ok(CoordinatorRequest::ScheduleUnbindChildren {
                        responder: CoordinatorScheduleUnbindChildrenResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x274db0bd334639ca => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(CoordinatorBindDeviceRequest);
                    fidl::encoding::Decoder::decode_into::<CoordinatorBindDeviceRequest>(
                        &header,
                        _body_bytes,
                        handles,
                        &mut req,
                    )?;
                    let control_handle = CoordinatorControlHandle { inner: this.inner.clone() };
                    Ok(CoordinatorRequest::BindDevice {
                        driver_url_suffix: req.driver_url_suffix,

                        responder: CoordinatorBindDeviceResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x319ccef1252fd6bf => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
                    fidl::encoding::Decoder::decode_into::<fidl::encoding::EmptyPayload>(
                        &header,
                        _body_bytes,
                        handles,
                        &mut req,
                    )?;
                    let control_handle = CoordinatorControlHandle { inner: this.inner.clone() };
                    Ok(CoordinatorRequest::GetTopologicalPath {
                        responder: CoordinatorGetTopologicalPathResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x5c24700e7a9815bd => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(CoordinatorLoadFirmwareRequest);
                    fidl::encoding::Decoder::decode_into::<CoordinatorLoadFirmwareRequest>(
                        &header,
                        _body_bytes,
                        handles,
                        &mut req,
                    )?;
                    let control_handle = CoordinatorControlHandle { inner: this.inner.clone() };
                    Ok(CoordinatorRequest::LoadFirmware {
                        driver_path: req.driver_path,
                        fw_path: req.fw_path,

                        responder: CoordinatorLoadFirmwareResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x34abe1351145bf3f => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(CoordinatorGetMetadataRequest);
                    fidl::encoding::Decoder::decode_into::<CoordinatorGetMetadataRequest>(
                        &header,
                        _body_bytes,
                        handles,
                        &mut req,
                    )?;
                    let control_handle = CoordinatorControlHandle { inner: this.inner.clone() };
                    Ok(CoordinatorRequest::GetMetadata {
                        key: req.key,

                        responder: CoordinatorGetMetadataResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x290826b5b7483d61 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(CoordinatorGetMetadataSizeRequest);
                    fidl::encoding::Decoder::decode_into::<CoordinatorGetMetadataSizeRequest>(
                        &header,
                        _body_bytes,
                        handles,
                        &mut req,
                    )?;
                    let control_handle = CoordinatorControlHandle { inner: this.inner.clone() };
                    Ok(CoordinatorRequest::GetMetadataSize {
                        key: req.key,

                        responder: CoordinatorGetMetadataSizeResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x7acb84ea4eb23c94 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(CoordinatorAddMetadataRequest);
                    fidl::encoding::Decoder::decode_into::<CoordinatorAddMetadataRequest>(
                        &header,
                        _body_bytes,
                        handles,
                        &mut req,
                    )?;
                    let control_handle = CoordinatorControlHandle { inner: this.inner.clone() };
                    Ok(CoordinatorRequest::AddMetadata {
                        key: req.key,
                        data: req.data,

                        responder: CoordinatorAddMetadataResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x1610b2d89769d054 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(CoordinatorAddCompositeDeviceRequest);
                    fidl::encoding::Decoder::decode_into::<CoordinatorAddCompositeDeviceRequest>(
                        &header,
                        _body_bytes,
                        handles,
                        &mut req,
                    )?;
                    let control_handle = CoordinatorControlHandle { inner: this.inner.clone() };
                    Ok(CoordinatorRequest::AddCompositeDevice {
                        name: req.name,
                        comp_desc: req.comp_desc,

                        responder: CoordinatorAddCompositeDeviceResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x1ecc89bad1ab5c75 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(CoordinatorAddCompositeNodeSpecRequest);
                    fidl::encoding::Decoder::decode_into::<CoordinatorAddCompositeNodeSpecRequest>(
                        &header,
                        _body_bytes,
                        handles,
                        &mut req,
                    )?;
                    let control_handle = CoordinatorControlHandle { inner: this.inner.clone() };
                    Ok(CoordinatorRequest::AddCompositeNodeSpec {
                        name: req.name,
                        spec: req.spec,

                        responder: CoordinatorAddCompositeNodeSpecResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x7c9861ff4ed7fc75 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(CoordinatorConnectFidlProtocolRequest);
                    fidl::encoding::Decoder::decode_into::<CoordinatorConnectFidlProtocolRequest>(
                        &header,
                        _body_bytes,
                        handles,
                        &mut req,
                    )?;
                    let control_handle = CoordinatorControlHandle { inner: this.inner.clone() };
                    Ok(CoordinatorRequest::ConnectFidlProtocol {
                        fragment_name: req.fragment_name,
                        service_name: req.service_name,
                        protocol_name: req.protocol_name,
                        server: req.server,

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

/// Interface for drivers in driver host to coordinate with the driver
/// manager.
#[derive(Debug)]
pub enum CoordinatorRequest {
    /// Record the addition of a new device that can be communicated with via `device_controller`.
    /// On success, the returned `local_device_id` is the identifier assigned by devmgr.
    AddDevice {
        args: AddDeviceArgs,
        coordinator: fidl::endpoints::ServerEnd<CoordinatorMarker>,
        device_controller: fidl::endpoints::ClientEnd<DeviceControllerMarker>,
        inspect: Option<fidl::Vmo>,
        outgoing_dir: Option<fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>>,
        responder: CoordinatorAddDeviceResponder,
    },
    /// Requests the devcoordinator schedule the removal of this device,
    /// and the unbinding of its children.
    /// If `unbind_self` is true, the unbind hook for this device will also be called.
    ScheduleRemove { unbind_self: bool, control_handle: CoordinatorControlHandle },
    /// Requests the devcoordinator schedule the unbinding of this device's children.
    /// If the device has no children, no request will be sent, and `has_children` will be false.
    ScheduleUnbindChildren { responder: CoordinatorScheduleUnbindChildrenResponder },
    /// Attempt to bind a driver against this device.
    /// + request `driver_url_suffix` only driver's that match this URL suffix will try to bind to
    ///           the device (e.g: "fvm.cm").
    ///           If this is null, the API will autobind.
    /// * error `ZX_ERR_ALREADY_BOUND` if the device is already bound.
    /// * error `ZX_ERR_NOT_FOUND` no drivers were found.
    BindDevice { driver_url_suffix: Option<String>, responder: CoordinatorBindDeviceResponder },
    /// Returns the topological path of this device.
    GetTopologicalPath { responder: CoordinatorGetTopologicalPathResponder },
    /// Requests that the firmware at the given path be loaded and returned.
    LoadFirmware {
        driver_path: String,
        fw_path: String,
        responder: CoordinatorLoadFirmwareResponder,
    },
    /// Retrieve the metadata blob associated with this device and the given key.
    GetMetadata { key: u32, responder: CoordinatorGetMetadataResponder },
    /// Retrieve the metadata size associated with this device and the given key.
    GetMetadataSize { key: u32, responder: CoordinatorGetMetadataSizeResponder },
    /// Add metadata blob associated with this device and the given key.
    /// If the same key is specified multiple times, the new data will be
    /// ignored in favor of the data from first call with the specified key.
    AddMetadata { key: u32, data: Option<Vec<u8>>, responder: CoordinatorAddMetadataResponder },
    /// Adds the given composite device.  This causes the driver manager to try to match the
    /// fragments against the existing device tree, and to monitor all new device additions
    /// in order to find the fragments as they are created.
    AddCompositeDevice {
        name: String,
        comp_desc: CompositeDeviceDescriptor,
        responder: CoordinatorAddCompositeDeviceResponder,
    },
    /// Adds the given composite node spec. This causes the driver manager to add the spec to
    /// the driver index, and then try to match the parents against the node topology.
    /// All device additions will be monitored to see if they matched to the remaining
    /// unbound nodes.
    AddCompositeNodeSpec {
        name: String,
        spec: CompositeNodeSpecDescriptor,
        responder: CoordinatorAddCompositeNodeSpecResponder,
    },
    /// Connects the given FIDL protocol inside of a FIDL service. Connection is completed
    /// asynchronously due to pipelining. Returning `ZX_OK` does not imply the service exists. A
    /// two way call to the service via the retained client end of the channel pair must be issued
    /// in order to ascertain whether the connection has been successfully established.
    /// + |fragment_name| should be specified if the parent is a composite node.
    /// + |service_name| should be specified if attempting to connect to a service. This will be
    ///   mandatory in the future: http://fxbug.dev/107155.
    /// * error Reports `ZX_ERR_UNAVAILABLE` if the parent (or fragment) does not have an outgoing
    ///   directory.
    /// * error Reports `ZX_ERR_NOT_FOUND` if |fragment_name| is not the name of a parent.
    /// * error Reports `ZX_ERR_NOT_SUPPORTED` if |fragment_name| is specified by the device is not
    ///   a composite node
    ConnectFidlProtocol {
        fragment_name: Option<String>,
        service_name: Option<String>,
        protocol_name: String,
        server: fidl::Channel,
        responder: CoordinatorConnectFidlProtocolResponder,
    },
}

impl CoordinatorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_add_device(
        self,
    ) -> Option<(
        AddDeviceArgs,
        fidl::endpoints::ServerEnd<CoordinatorMarker>,
        fidl::endpoints::ClientEnd<DeviceControllerMarker>,
        Option<fidl::Vmo>,
        Option<fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>>,
        CoordinatorAddDeviceResponder,
    )> {
        if let CoordinatorRequest::AddDevice {
            args,
            coordinator,
            device_controller,
            inspect,
            outgoing_dir,
            responder,
        } = self
        {
            Some((args, coordinator, device_controller, inspect, outgoing_dir, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_schedule_remove(self) -> Option<(bool, CoordinatorControlHandle)> {
        if let CoordinatorRequest::ScheduleRemove { unbind_self, control_handle } = self {
            Some((unbind_self, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_schedule_unbind_children(
        self,
    ) -> Option<(CoordinatorScheduleUnbindChildrenResponder)> {
        if let CoordinatorRequest::ScheduleUnbindChildren { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_bind_device(self) -> Option<(Option<String>, CoordinatorBindDeviceResponder)> {
        if let CoordinatorRequest::BindDevice { driver_url_suffix, responder } = self {
            Some((driver_url_suffix, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_topological_path(self) -> Option<(CoordinatorGetTopologicalPathResponder)> {
        if let CoordinatorRequest::GetTopologicalPath { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_load_firmware(self) -> Option<(String, String, CoordinatorLoadFirmwareResponder)> {
        if let CoordinatorRequest::LoadFirmware { driver_path, fw_path, responder } = self {
            Some((driver_path, fw_path, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_metadata(self) -> Option<(u32, CoordinatorGetMetadataResponder)> {
        if let CoordinatorRequest::GetMetadata { key, responder } = self {
            Some((key, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_metadata_size(self) -> Option<(u32, CoordinatorGetMetadataSizeResponder)> {
        if let CoordinatorRequest::GetMetadataSize { key, responder } = self {
            Some((key, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_metadata(
        self,
    ) -> Option<(u32, Option<Vec<u8>>, CoordinatorAddMetadataResponder)> {
        if let CoordinatorRequest::AddMetadata { key, data, responder } = self {
            Some((key, data, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_composite_device(
        self,
    ) -> Option<(String, CompositeDeviceDescriptor, CoordinatorAddCompositeDeviceResponder)> {
        if let CoordinatorRequest::AddCompositeDevice { name, comp_desc, responder } = self {
            Some((name, comp_desc, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_composite_node_spec(
        self,
    ) -> Option<(String, CompositeNodeSpecDescriptor, CoordinatorAddCompositeNodeSpecResponder)>
    {
        if let CoordinatorRequest::AddCompositeNodeSpec { name, spec, responder } = self {
            Some((name, spec, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_connect_fidl_protocol(
        self,
    ) -> Option<(
        Option<String>,
        Option<String>,
        String,
        fidl::Channel,
        CoordinatorConnectFidlProtocolResponder,
    )> {
        if let CoordinatorRequest::ConnectFidlProtocol {
            fragment_name,
            service_name,
            protocol_name,
            server,
            responder,
        } = self
        {
            Some((fragment_name, service_name, protocol_name, server, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            CoordinatorRequest::AddDevice { .. } => "add_device",
            CoordinatorRequest::ScheduleRemove { .. } => "schedule_remove",
            CoordinatorRequest::ScheduleUnbindChildren { .. } => "schedule_unbind_children",
            CoordinatorRequest::BindDevice { .. } => "bind_device",
            CoordinatorRequest::GetTopologicalPath { .. } => "get_topological_path",
            CoordinatorRequest::LoadFirmware { .. } => "load_firmware",
            CoordinatorRequest::GetMetadata { .. } => "get_metadata",
            CoordinatorRequest::GetMetadataSize { .. } => "get_metadata_size",
            CoordinatorRequest::AddMetadata { .. } => "add_metadata",
            CoordinatorRequest::AddCompositeDevice { .. } => "add_composite_device",
            CoordinatorRequest::AddCompositeNodeSpec { .. } => "add_composite_node_spec",
            CoordinatorRequest::ConnectFidlProtocol { .. } => "connect_fidl_protocol",
        }
    }
}

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

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

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

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }

    fn on_closed<'a>(&'a self) -> fidl::OnSignals<'a> {
        self.inner.channel().on_closed()
    }
}

impl CoordinatorControlHandle {}

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut result: Result<bool, i32>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            CoordinatorScheduleUnbindChildrenResponse,
            i32,
        >>(
            result.map(|has_children| (has_children,)),
            self.tx_id,
            0x658a6d68027b7139,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

    fn send_raw(&self, mut result: Result<&str, i32>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            CoordinatorGetTopologicalPathResponse,
            i32,
        >>(
            result.map(|path| (path,)),
            self.tx_id,
            0x319ccef1252fd6bf,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

    fn control_handle(&self) -> &CoordinatorControlHandle {
        &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 CoordinatorGetMetadataResponder {
    /// 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<CoordinatorGetMetadataResponse, i32>>(
                result.map(|data| (data,)),
                self.tx_id,
                0x34abe1351145bf3f,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for DeviceControllerMarker {
    type Proxy = DeviceControllerProxy;
    type RequestStream = DeviceControllerRequestStream;
    const DEBUG_NAME: &'static str = "(anonymous) DeviceController";
}
pub type DeviceControllerUnbindResult = Result<(), i32>;
pub type DeviceControllerCompleteRemovalResult = Result<(), i32>;

pub trait DeviceControllerProxyInterface: Send + Sync {
    fn r#connect_multiplexed(
        &self,
        server: fidl::Channel,
        include_node: bool,
        include_controller: bool,
    ) -> Result<(), fidl::Error>;
    fn r#connect_to_controller(
        &self,
        controller: fidl::endpoints::ServerEnd<fidl_fuchsia_device::ControllerMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#connect_to_device_protocol(&self, server: fidl::Channel) -> Result<(), fidl::Error>;
    type BindDriverResponseFut: std::future::Future<Output = Result<(i32, Option<fidl::Channel>), fidl::Error>>
        + Send;
    fn r#bind_driver(
        &self,
        driver_path: &str,
        driver: fidl::Vmo,
        default_dispatcher_scheduler_role: &str,
    ) -> Self::BindDriverResponseFut;
    fn r#connect_proxy_(&self, shadow: fidl::Channel) -> Result<(), fidl::Error>;
    type InitResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#init(&self) -> Self::InitResponseFut;
    type UnbindResponseFut: std::future::Future<Output = Result<DeviceControllerUnbindResult, fidl::Error>>
        + Send;
    fn r#unbind(&self) -> Self::UnbindResponseFut;
    type CompleteRemovalResponseFut: std::future::Future<Output = Result<DeviceControllerCompleteRemovalResult, fidl::Error>>
        + Send;
    fn r#complete_removal(&self) -> Self::CompleteRemovalResponseFut;
    type SuspendResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#suspend(&self, flags: u32) -> Self::SuspendResponseFut;
    type ResumeResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#resume(&self, target_system_state: u32) -> Self::ResumeResponseFut;
    fn r#signal_made_visible(&self) -> Result<(), fidl::Error>;
}

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

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

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

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

    /// Connect to the device's FIDL, but also include other FIDLs multiplexed on the same channel.
    ///
    /// + request `include_node` if this is true then include fuchsia.io/Node on the channel.
    /// + request `include_controller` if this is true then include fuchsia.device/Controller on the channel.
    pub fn r#connect_multiplexed(
        &self,
        mut server: fidl::Channel,
        mut include_node: bool,
        mut include_controller: bool,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DeviceControllerConnectMultiplexedRequest>(
            (server, include_node, include_controller),
            0x3797e17a468d5808,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Connect to the device's fuchsia.device/Controller API.
    pub fn r#connect_to_controller(
        &self,
        mut controller: fidl::endpoints::ServerEnd<fidl_fuchsia_device::ControllerMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DeviceControllerConnectToControllerRequest>(
            (controller,),
            0x492ba92efb266b2a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Connect to the device's API.
    ///
    /// NOTE: This is not multiplexed with fuchsia.io/Node or fuchsia.device/Controller.
    pub fn r#connect_to_device_protocol(
        &self,
        mut server: fidl::Channel,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DeviceControllerConnectToDeviceProtocolRequest>(
            (server,),
            0x65c280a3b9cb9300,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Bind the requested driver to this device.  `driver_path` is informational,
    /// but all calls to BindDriver/CreateDevice should use the same `driver_path`
    /// each time they use a `driver` VMO with the same contents. Returns a `status`
    /// and optionally a channel to the driver's test output. `test_output` will be
    /// not present unless the driver is configured to run its run_unit_tests hook, in
    /// which case the other end of the channel will have been passed to the driver.
    ///
    /// + request `default_dispatcher_scheduler_role` the scheduler role to set for
    /// the default dispatcher created for the driver. The scheduler role determines
    /// the thread pool that the dispatcher will be serviced by. This may be an empty
    /// string if the driver does not require the dispatcher to run in a specific
    /// thread pool. Setting a scheduler role is on a best-effort basis. If an invalid
    /// scheduler role is specified, the dispatcher will be serviced by the default
    /// thread pool, and this will not cause an error to be returned.
    pub fn r#bind_driver(
        &self,
        mut driver_path: &str,
        mut driver: fidl::Vmo,
        mut default_dispatcher_scheduler_role: &str,
        ___deadline: zx::Time,
    ) -> Result<(i32, Option<fidl::Channel>), fidl::Error> {
        let _response = self
            .client
            .send_query::<DeviceControllerBindDriverRequest, DeviceControllerBindDriverResponse>(
                (driver_path, driver, default_dispatcher_scheduler_role),
                0x1600a1d1d6024855,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok((_response.status, _response.test_output))
    }

    /// Give this device a channel to its shadow in another process.
    pub fn r#connect_proxy_(&self, mut shadow: fidl::Channel) -> Result<(), fidl::Error> {
        self.client.send::<DeviceControllerConnectProxyRequest>(
            (shadow,),
            0x72206da90d1f3f2f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Ask devhost to call the device init hook.
    pub fn r#init(&self, ___deadline: zx::Time) -> Result<i32, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, DeviceControllerInitResponse>(
                (),
                0x4443bcf5eb580b37,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.status)
    }

    /// Ask devhost to unbind this device. On success, the remote end of this
    /// interface channel will close instead of returning a result.
    pub fn r#unbind(
        &self,
        ___deadline: zx::Time,
    ) -> Result<DeviceControllerUnbindResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (),
            0x2d3f793e42cc3fd0,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Ask the devhost to complete the removal of this device, which previously had
    /// invoked `ScheduleRemove`. This is a special case that can be removed
    /// once `device_remove` invokes `unbind`.
    pub fn r#complete_removal(
        &self,
        ___deadline: zx::Time,
    ) -> Result<DeviceControllerCompleteRemovalResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (),
            0x25d6d94c85d60771,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Ask devhost to suspend this device, using the target state indicated by `flags`.
    pub fn r#suspend(&self, mut flags: u32, ___deadline: zx::Time) -> Result<i32, fidl::Error> {
        let _response = self
            .client
            .send_query::<DeviceControllerSuspendRequest, DeviceControllerSuspendResponse>(
                (flags,),
                0x77bf98a1d5d4adbb,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.status)
    }

    /// Ask devhost to resume this device, using the target system state indicated by
    /// 'target_system_state'.
    pub fn r#resume(
        &self,
        mut target_system_state: u32,
        ___deadline: zx::Time,
    ) -> Result<i32, fidl::Error> {
        let _response = self
            .client
            .send_query::<DeviceControllerResumeRequest, DeviceControllerResumeResponse>(
                (target_system_state,),
                0x4f111286b7bd9caf,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.status)
    }

    /// Informs the driver that it has been made visible in devfs.
    pub fn r#signal_made_visible(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0xed921108aead7c5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::Proxy for DeviceControllerProxy {
    type Protocol = DeviceControllerMarker;

    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 DeviceControllerProxy {
    /// Create a new Proxy for fuchsia.device.manager/DeviceController.
    pub fn new(channel: fidl::AsyncChannel) -> Self {
        let protocol_name = <DeviceControllerMarker 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) -> DeviceControllerEventStream {
        DeviceControllerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Connect to the device's FIDL, but also include other FIDLs multiplexed on the same channel.
    ///
    /// + request `include_node` if this is true then include fuchsia.io/Node on the channel.
    /// + request `include_controller` if this is true then include fuchsia.device/Controller on the channel.
    pub fn r#connect_multiplexed(
        &self,
        mut server: fidl::Channel,
        mut include_node: bool,
        mut include_controller: bool,
    ) -> Result<(), fidl::Error> {
        DeviceControllerProxyInterface::r#connect_multiplexed(
            self,
            server,
            include_node,
            include_controller,
        )
    }

    /// Connect to the device's fuchsia.device/Controller API.
    pub fn r#connect_to_controller(
        &self,
        mut controller: fidl::endpoints::ServerEnd<fidl_fuchsia_device::ControllerMarker>,
    ) -> Result<(), fidl::Error> {
        DeviceControllerProxyInterface::r#connect_to_controller(self, controller)
    }

    /// Connect to the device's API.
    ///
    /// NOTE: This is not multiplexed with fuchsia.io/Node or fuchsia.device/Controller.
    pub fn r#connect_to_device_protocol(
        &self,
        mut server: fidl::Channel,
    ) -> Result<(), fidl::Error> {
        DeviceControllerProxyInterface::r#connect_to_device_protocol(self, server)
    }

    /// Bind the requested driver to this device.  `driver_path` is informational,
    /// but all calls to BindDriver/CreateDevice should use the same `driver_path`
    /// each time they use a `driver` VMO with the same contents. Returns a `status`
    /// and optionally a channel to the driver's test output. `test_output` will be
    /// not present unless the driver is configured to run its run_unit_tests hook, in
    /// which case the other end of the channel will have been passed to the driver.
    ///
    /// + request `default_dispatcher_scheduler_role` the scheduler role to set for
    /// the default dispatcher created for the driver. The scheduler role determines
    /// the thread pool that the dispatcher will be serviced by. This may be an empty
    /// string if the driver does not require the dispatcher to run in a specific
    /// thread pool. Setting a scheduler role is on a best-effort basis. If an invalid
    /// scheduler role is specified, the dispatcher will be serviced by the default
    /// thread pool, and this will not cause an error to be returned.
    pub fn r#bind_driver(
        &self,
        mut driver_path: &str,
        mut driver: fidl::Vmo,
        mut default_dispatcher_scheduler_role: &str,
    ) -> fidl::client::QueryResponseFut<(i32, Option<fidl::Channel>)> {
        DeviceControllerProxyInterface::r#bind_driver(
            self,
            driver_path,
            driver,
            default_dispatcher_scheduler_role,
        )
    }

    /// Give this device a channel to its shadow in another process.
    pub fn r#connect_proxy_(&self, mut shadow: fidl::Channel) -> Result<(), fidl::Error> {
        DeviceControllerProxyInterface::r#connect_proxy_(self, shadow)
    }

    /// Ask devhost to call the device init hook.
    pub fn r#init(&self) -> fidl::client::QueryResponseFut<i32> {
        DeviceControllerProxyInterface::r#init(self)
    }

    /// Ask devhost to unbind this device. On success, the remote end of this
    /// interface channel will close instead of returning a result.
    pub fn r#unbind(&self) -> fidl::client::QueryResponseFut<DeviceControllerUnbindResult> {
        DeviceControllerProxyInterface::r#unbind(self)
    }

    /// Ask the devhost to complete the removal of this device, which previously had
    /// invoked `ScheduleRemove`. This is a special case that can be removed
    /// once `device_remove` invokes `unbind`.
    pub fn r#complete_removal(
        &self,
    ) -> fidl::client::QueryResponseFut<DeviceControllerCompleteRemovalResult> {
        DeviceControllerProxyInterface::r#complete_removal(self)
    }

    /// Ask devhost to suspend this device, using the target state indicated by `flags`.
    pub fn r#suspend(&self, mut flags: u32) -> fidl::client::QueryResponseFut<i32> {
        DeviceControllerProxyInterface::r#suspend(self, flags)
    }

    /// Ask devhost to resume this device, using the target system state indicated by
    /// 'target_system_state'.
    pub fn r#resume(&self, mut target_system_state: u32) -> fidl::client::QueryResponseFut<i32> {
        DeviceControllerProxyInterface::r#resume(self, target_system_state)
    }

    /// Informs the driver that it has been made visible in devfs.
    pub fn r#signal_made_visible(&self) -> Result<(), fidl::Error> {
        DeviceControllerProxyInterface::r#signal_made_visible(self)
    }
}

impl DeviceControllerProxyInterface for DeviceControllerProxy {
    fn r#connect_multiplexed(
        &self,
        mut server: fidl::Channel,
        mut include_node: bool,
        mut include_controller: bool,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DeviceControllerConnectMultiplexedRequest>(
            (server, include_node, include_controller),
            0x3797e17a468d5808,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#connect_to_controller(
        &self,
        mut controller: fidl::endpoints::ServerEnd<fidl_fuchsia_device::ControllerMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DeviceControllerConnectToControllerRequest>(
            (controller,),
            0x492ba92efb266b2a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#connect_to_device_protocol(&self, mut server: fidl::Channel) -> Result<(), fidl::Error> {
        self.client.send::<DeviceControllerConnectToDeviceProtocolRequest>(
            (server,),
            0x65c280a3b9cb9300,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type BindDriverResponseFut = fidl::client::QueryResponseFut<(i32, Option<fidl::Channel>)>;
    fn r#bind_driver(
        &self,
        mut driver_path: &str,
        mut driver: fidl::Vmo,
        mut default_dispatcher_scheduler_role: &str,
    ) -> Self::BindDriverResponseFut {
        fn _decode(
            mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, Option<fidl::Channel>), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DeviceControllerBindDriverResponse,
                0x1600a1d1d6024855,
            >(_buf?)?;
            Ok((_response.status, _response.test_output))
        }
        self.client.send_query_and_decode::<
            DeviceControllerBindDriverRequest,
            (i32, Option<fidl::Channel>),
        >(
            (driver_path, driver, default_dispatcher_scheduler_role,),
            0x1600a1d1d6024855,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#connect_proxy_(&self, mut shadow: fidl::Channel) -> Result<(), fidl::Error> {
        self.client.send::<DeviceControllerConnectProxyRequest>(
            (shadow,),
            0x72206da90d1f3f2f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type InitResponseFut = fidl::client::QueryResponseFut<i32>;
    fn r#init(&self) -> Self::InitResponseFut {
        fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DeviceControllerInitResponse,
                0x4443bcf5eb580b37,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, i32>(
            (),
            0x4443bcf5eb580b37,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

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

    type SuspendResponseFut = fidl::client::QueryResponseFut<i32>;
    fn r#suspend(&self, mut flags: u32) -> Self::SuspendResponseFut {
        fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DeviceControllerSuspendResponse,
                0x77bf98a1d5d4adbb,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<DeviceControllerSuspendRequest, i32>(
            (flags,),
            0x77bf98a1d5d4adbb,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ResumeResponseFut = fidl::client::QueryResponseFut<i32>;
    fn r#resume(&self, mut target_system_state: u32) -> Self::ResumeResponseFut {
        fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DeviceControllerResumeResponse,
                0x4f111286b7bd9caf,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<DeviceControllerResumeRequest, i32>(
            (target_system_state,),
            0x4f111286b7bd9caf,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.device.manager/DeviceController.
pub struct DeviceControllerRequestStream {
    inner: std::sync::Arc<fidl::ServeInner>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for DeviceControllerRequestStream {
    type Protocol = DeviceControllerMarker;
    type ControlHandle = DeviceControllerControlHandle;

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

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

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

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

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

            std::task::Poll::Ready(Some(match header.ordinal {
                0x3797e17a468d5808 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(DeviceControllerConnectMultiplexedRequest);
                    fidl::encoding::Decoder::decode_into::<
                        DeviceControllerConnectMultiplexedRequest,
                    >(&header, _body_bytes, handles, &mut req)?;
                    let control_handle =
                        DeviceControllerControlHandle { inner: this.inner.clone() };
                    Ok(DeviceControllerRequest::ConnectMultiplexed {
                        server: req.server,
                        include_node: req.include_node,
                        include_controller: req.include_controller,

                        control_handle,
                    })
                }
                0x492ba92efb266b2a => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(DeviceControllerConnectToControllerRequest);
                    fidl::encoding::Decoder::decode_into::<
                        DeviceControllerConnectToControllerRequest,
                    >(&header, _body_bytes, handles, &mut req)?;
                    let control_handle =
                        DeviceControllerControlHandle { inner: this.inner.clone() };
                    Ok(DeviceControllerRequest::ConnectToController {
                        controller: req.controller,

                        control_handle,
                    })
                }
                0x65c280a3b9cb9300 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(DeviceControllerConnectToDeviceProtocolRequest);
                    fidl::encoding::Decoder::decode_into::<
                        DeviceControllerConnectToDeviceProtocolRequest,
                    >(&header, _body_bytes, handles, &mut req)?;
                    let control_handle =
                        DeviceControllerControlHandle { inner: this.inner.clone() };
                    Ok(DeviceControllerRequest::ConnectToDeviceProtocol {
                        server: req.server,

                        control_handle,
                    })
                }
                0x1600a1d1d6024855 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(DeviceControllerBindDriverRequest);
                    fidl::encoding::Decoder::decode_into::<DeviceControllerBindDriverRequest>(
                        &header,
                        _body_bytes,
                        handles,
                        &mut req,
                    )?;
                    let control_handle =
                        DeviceControllerControlHandle { inner: this.inner.clone() };
                    Ok(DeviceControllerRequest::BindDriver {
                        driver_path: req.driver_path,
                        driver: req.driver,
                        default_dispatcher_scheduler_role: req.default_dispatcher_scheduler_role,

                        responder: DeviceControllerBindDriverResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x72206da90d1f3f2f => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(DeviceControllerConnectProxyRequest);
                    fidl::encoding::Decoder::decode_into::<DeviceControllerConnectProxyRequest>(
                        &header,
                        _body_bytes,
                        handles,
                        &mut req,
                    )?;
                    let control_handle =
                        DeviceControllerControlHandle { inner: this.inner.clone() };
                    Ok(DeviceControllerRequest::ConnectProxy_ {
                        shadow: req.shadow,

                        control_handle,
                    })
                }
                0x4443bcf5eb580b37 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
                    fidl::encoding::Decoder::decode_into::<fidl::encoding::EmptyPayload>(
                        &header,
                        _body_bytes,
                        handles,
                        &mut req,
                    )?;
                    let control_handle =
                        DeviceControllerControlHandle { inner: this.inner.clone() };
                    Ok(DeviceControllerRequest::Init {
                        responder: DeviceControllerInitResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x2d3f793e42cc3fd0 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
                    fidl::encoding::Decoder::decode_into::<fidl::encoding::EmptyPayload>(
                        &header,
                        _body_bytes,
                        handles,
                        &mut req,
                    )?;
                    let control_handle =
                        DeviceControllerControlHandle { inner: this.inner.clone() };
                    Ok(DeviceControllerRequest::Unbind {
                        responder: DeviceControllerUnbindResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x25d6d94c85d60771 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
                    fidl::encoding::Decoder::decode_into::<fidl::encoding::EmptyPayload>(
                        &header,
                        _body_bytes,
                        handles,
                        &mut req,
                    )?;
                    let control_handle =
                        DeviceControllerControlHandle { inner: this.inner.clone() };
                    Ok(DeviceControllerRequest::CompleteRemoval {
                        responder: DeviceControllerCompleteRemovalResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x77bf98a1d5d4adbb => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(DeviceControllerSuspendRequest);
                    fidl::encoding::Decoder::decode_into::<DeviceControllerSuspendRequest>(
                        &header,
                        _body_bytes,
                        handles,
                        &mut req,
                    )?;
                    let control_handle =
                        DeviceControllerControlHandle { inner: this.inner.clone() };
                    Ok(DeviceControllerRequest::Suspend {
                        flags: req.flags,

                        responder: DeviceControllerSuspendResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x4f111286b7bd9caf => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(DeviceControllerResumeRequest);
                    fidl::encoding::Decoder::decode_into::<DeviceControllerResumeRequest>(
                        &header,
                        _body_bytes,
                        handles,
                        &mut req,
                    )?;
                    let control_handle =
                        DeviceControllerControlHandle { inner: this.inner.clone() };
                    Ok(DeviceControllerRequest::Resume {
                        target_system_state: req.target_system_state,

                        responder: DeviceControllerResumeResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0xed921108aead7c5 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
                    fidl::encoding::Decoder::decode_into::<fidl::encoding::EmptyPayload>(
                        &header,
                        _body_bytes,
                        handles,
                        &mut req,
                    )?;
                    let control_handle =
                        DeviceControllerControlHandle { inner: this.inner.clone() };
                    Ok(DeviceControllerRequest::SignalMadeVisible { control_handle })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name:
                        <DeviceControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
        })
    }
}

/// Protocol for controlling devices in a devhost process from the devcoordinator
#[derive(Debug)]
pub enum DeviceControllerRequest {
    /// Connect to the device's FIDL, but also include other FIDLs multiplexed on the same channel.
    ///
    /// + request `include_node` if this is true then include fuchsia.io/Node on the channel.
    /// + request `include_controller` if this is true then include fuchsia.device/Controller on the channel.
    ConnectMultiplexed {
        server: fidl::Channel,
        include_node: bool,
        include_controller: bool,
        control_handle: DeviceControllerControlHandle,
    },
    /// Connect to the device's fuchsia.device/Controller API.
    ConnectToController {
        controller: fidl::endpoints::ServerEnd<fidl_fuchsia_device::ControllerMarker>,
        control_handle: DeviceControllerControlHandle,
    },
    /// Connect to the device's API.
    ///
    /// NOTE: This is not multiplexed with fuchsia.io/Node or fuchsia.device/Controller.
    ConnectToDeviceProtocol { server: fidl::Channel, control_handle: DeviceControllerControlHandle },
    /// Bind the requested driver to this device.  `driver_path` is informational,
    /// but all calls to BindDriver/CreateDevice should use the same `driver_path`
    /// each time they use a `driver` VMO with the same contents. Returns a `status`
    /// and optionally a channel to the driver's test output. `test_output` will be
    /// not present unless the driver is configured to run its run_unit_tests hook, in
    /// which case the other end of the channel will have been passed to the driver.
    ///
    /// + request `default_dispatcher_scheduler_role` the scheduler role to set for
    /// the default dispatcher created for the driver. The scheduler role determines
    /// the thread pool that the dispatcher will be serviced by. This may be an empty
    /// string if the driver does not require the dispatcher to run in a specific
    /// thread pool. Setting a scheduler role is on a best-effort basis. If an invalid
    /// scheduler role is specified, the dispatcher will be serviced by the default
    /// thread pool, and this will not cause an error to be returned.
    BindDriver {
        driver_path: String,
        driver: fidl::Vmo,
        default_dispatcher_scheduler_role: String,
        responder: DeviceControllerBindDriverResponder,
    },
    /// Give this device a channel to its shadow in another process.
    ConnectProxy_ { shadow: fidl::Channel, control_handle: DeviceControllerControlHandle },
    /// Ask devhost to call the device init hook.
    Init { responder: DeviceControllerInitResponder },
    /// Ask devhost to unbind this device. On success, the remote end of this
    /// interface channel will close instead of returning a result.
    Unbind { responder: DeviceControllerUnbindResponder },
    /// Ask the devhost to complete the removal of this device, which previously had
    /// invoked `ScheduleRemove`. This is a special case that can be removed
    /// once `device_remove` invokes `unbind`.
    CompleteRemoval { responder: DeviceControllerCompleteRemovalResponder },
    /// Ask devhost to suspend this device, using the target state indicated by `flags`.
    Suspend { flags: u32, responder: DeviceControllerSuspendResponder },
    /// Ask devhost to resume this device, using the target system state indicated by
    /// 'target_system_state'.
    Resume { target_system_state: u32, responder: DeviceControllerResumeResponder },
    /// Informs the driver that it has been made visible in devfs.
    SignalMadeVisible { control_handle: DeviceControllerControlHandle },
}

impl DeviceControllerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_connect_multiplexed(
        self,
    ) -> Option<(fidl::Channel, bool, bool, DeviceControllerControlHandle)> {
        if let DeviceControllerRequest::ConnectMultiplexed {
            server,
            include_node,
            include_controller,
            control_handle,
        } = self
        {
            Some((server, include_node, include_controller, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_connect_to_controller(
        self,
    ) -> Option<(
        fidl::endpoints::ServerEnd<fidl_fuchsia_device::ControllerMarker>,
        DeviceControllerControlHandle,
    )> {
        if let DeviceControllerRequest::ConnectToController { controller, control_handle } = self {
            Some((controller, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_connect_to_device_protocol(
        self,
    ) -> Option<(fidl::Channel, DeviceControllerControlHandle)> {
        if let DeviceControllerRequest::ConnectToDeviceProtocol { server, control_handle } = self {
            Some((server, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_bind_driver(
        self,
    ) -> Option<(String, fidl::Vmo, String, DeviceControllerBindDriverResponder)> {
        if let DeviceControllerRequest::BindDriver {
            driver_path,
            driver,
            default_dispatcher_scheduler_role,
            responder,
        } = self
        {
            Some((driver_path, driver, default_dispatcher_scheduler_role, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_connect_proxy_(self) -> Option<(fidl::Channel, DeviceControllerControlHandle)> {
        if let DeviceControllerRequest::ConnectProxy_ { shadow, control_handle } = self {
            Some((shadow, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_init(self) -> Option<(DeviceControllerInitResponder)> {
        if let DeviceControllerRequest::Init { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_unbind(self) -> Option<(DeviceControllerUnbindResponder)> {
        if let DeviceControllerRequest::Unbind { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_complete_removal(self) -> Option<(DeviceControllerCompleteRemovalResponder)> {
        if let DeviceControllerRequest::CompleteRemoval { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_suspend(self) -> Option<(u32, DeviceControllerSuspendResponder)> {
        if let DeviceControllerRequest::Suspend { flags, responder } = self {
            Some((flags, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_resume(self) -> Option<(u32, DeviceControllerResumeResponder)> {
        if let DeviceControllerRequest::Resume { target_system_state, responder } = self {
            Some((target_system_state, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_signal_made_visible(self) -> Option<(DeviceControllerControlHandle)> {
        if let DeviceControllerRequest::SignalMadeVisible { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            DeviceControllerRequest::ConnectMultiplexed { .. } => "connect_multiplexed",
            DeviceControllerRequest::ConnectToController { .. } => "connect_to_controller",
            DeviceControllerRequest::ConnectToDeviceProtocol { .. } => "connect_to_device_protocol",
            DeviceControllerRequest::BindDriver { .. } => "bind_driver",
            DeviceControllerRequest::ConnectProxy_ { .. } => "connect_proxy_",
            DeviceControllerRequest::Init { .. } => "init",
            DeviceControllerRequest::Unbind { .. } => "unbind",
            DeviceControllerRequest::CompleteRemoval { .. } => "complete_removal",
            DeviceControllerRequest::Suspend { .. } => "suspend",
            DeviceControllerRequest::Resume { .. } => "resume",
            DeviceControllerRequest::SignalMadeVisible { .. } => "signal_made_visible",
        }
    }
}

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

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

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

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }

    fn on_closed<'a>(&'a self) -> fidl::OnSignals<'a> {
        self.inner.channel().on_closed()
    }
}

impl DeviceControllerControlHandle {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for DriverHostControllerMarker {
    type Proxy = DriverHostControllerProxy;
    type RequestStream = DriverHostControllerRequestStream;
    const DEBUG_NAME: &'static str = "(anonymous) DriverHostController";
}

pub trait DriverHostControllerProxyInterface: Send + Sync {
    type CreateDeviceResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#create_device(
        &self,
        coordinator: fidl::endpoints::ClientEnd<CoordinatorMarker>,
        device_controller: fidl::endpoints::ServerEnd<DeviceControllerMarker>,
        type_: DeviceType,
        local_device_id: u64,
    ) -> Self::CreateDeviceResponseFut;
    type RestartResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#restart(&self) -> Self::RestartResponseFut;
}

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

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

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

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

    /// Create a device in the driver host. |type| describes what type of device
    /// is set up, how it communicates with its parent (if it has one).
    ///
    /// `local_device_id` will be a unique value within the device's devhost
    pub fn r#create_device(
        &self,
        mut coordinator: fidl::endpoints::ClientEnd<CoordinatorMarker>,
        mut device_controller: fidl::endpoints::ServerEnd<DeviceControllerMarker>,
        mut type_: DeviceType,
        mut local_device_id: u64,
        ___deadline: zx::Time,
    ) -> Result<i32, fidl::Error> {
        let _response = self.client.send_query::<
            DriverHostControllerCreateDeviceRequest,
            DriverHostControllerCreateDeviceResponse,
        >(
            (coordinator, device_controller, &mut type_, local_device_id,),
            0x5d136e167043e7de,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.status)
    }

    /// Request to restart the driver host. Also restarts all children devices and drivers and
    /// rebinds them once the Driver Host has restarted.
    pub fn r#restart(&self, ___deadline: zx::Time) -> Result<i32, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, DriverHostControllerRestartResponse>(
                (),
                0x1a870ec87b9fa33d,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.status)
    }
}

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

impl fidl::endpoints::Proxy for DriverHostControllerProxy {
    type Protocol = DriverHostControllerMarker;

    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 DriverHostControllerProxy {
    /// Create a new Proxy for fuchsia.device.manager/DriverHostController.
    pub fn new(channel: fidl::AsyncChannel) -> Self {
        let protocol_name =
            <DriverHostControllerMarker 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) -> DriverHostControllerEventStream {
        DriverHostControllerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Create a device in the driver host. |type| describes what type of device
    /// is set up, how it communicates with its parent (if it has one).
    ///
    /// `local_device_id` will be a unique value within the device's devhost
    pub fn r#create_device(
        &self,
        mut coordinator: fidl::endpoints::ClientEnd<CoordinatorMarker>,
        mut device_controller: fidl::endpoints::ServerEnd<DeviceControllerMarker>,
        mut type_: DeviceType,
        mut local_device_id: u64,
    ) -> fidl::client::QueryResponseFut<i32> {
        DriverHostControllerProxyInterface::r#create_device(
            self,
            coordinator,
            device_controller,
            type_,
            local_device_id,
        )
    }

    /// Request to restart the driver host. Also restarts all children devices and drivers and
    /// rebinds them once the Driver Host has restarted.
    pub fn r#restart(&self) -> fidl::client::QueryResponseFut<i32> {
        DriverHostControllerProxyInterface::r#restart(self)
    }
}

impl DriverHostControllerProxyInterface for DriverHostControllerProxy {
    type CreateDeviceResponseFut = fidl::client::QueryResponseFut<i32>;
    fn r#create_device(
        &self,
        mut coordinator: fidl::endpoints::ClientEnd<CoordinatorMarker>,
        mut device_controller: fidl::endpoints::ServerEnd<DeviceControllerMarker>,
        mut type_: DeviceType,
        mut local_device_id: u64,
    ) -> Self::CreateDeviceResponseFut {
        fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DriverHostControllerCreateDeviceResponse,
                0x5d136e167043e7de,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<DriverHostControllerCreateDeviceRequest, i32>(
            (coordinator, device_controller, &mut type_, local_device_id),
            0x5d136e167043e7de,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type RestartResponseFut = fidl::client::QueryResponseFut<i32>;
    fn r#restart(&self) -> Self::RestartResponseFut {
        fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DriverHostControllerRestartResponse,
                0x1a870ec87b9fa33d,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, i32>(
            (),
            0x1a870ec87b9fa33d,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.device.manager/DriverHostController.
pub struct DriverHostControllerRequestStream {
    inner: std::sync::Arc<fidl::ServeInner>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for DriverHostControllerRequestStream {
    type Protocol = DriverHostControllerMarker;
    type ControlHandle = DriverHostControllerControlHandle;

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

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

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

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

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

            std::task::Poll::Ready(Some(match header.ordinal {
                0x5d136e167043e7de => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(DriverHostControllerCreateDeviceRequest);
                    fidl::encoding::Decoder::decode_into::<DriverHostControllerCreateDeviceRequest>(
                        &header,
                        _body_bytes,
                        handles,
                        &mut req,
                    )?;
                    let control_handle =
                        DriverHostControllerControlHandle { inner: this.inner.clone() };
                    Ok(DriverHostControllerRequest::CreateDevice {
                        coordinator: req.coordinator,
                        device_controller: req.device_controller,
                        type_: req.type_,
                        local_device_id: req.local_device_id,

                        responder: DriverHostControllerCreateDeviceResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x1a870ec87b9fa33d => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
                    fidl::encoding::Decoder::decode_into::<fidl::encoding::EmptyPayload>(
                        &header,
                        _body_bytes,
                        handles,
                        &mut req,
                    )?;
                    let control_handle =
                        DriverHostControllerControlHandle { inner: this.inner.clone() };
                    Ok(DriverHostControllerRequest::Restart {
                        responder: DriverHostControllerRestartResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name:
                        <DriverHostControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
        })
    }
}

/// Protocol for controlling a driver host process from the driver manager
#[derive(Debug)]
pub enum DriverHostControllerRequest {
    /// Create a device in the driver host. |type| describes what type of device
    /// is set up, how it communicates with its parent (if it has one).
    ///
    /// `local_device_id` will be a unique value within the device's devhost
    CreateDevice {
        coordinator: fidl::endpoints::ClientEnd<CoordinatorMarker>,
        device_controller: fidl::endpoints::ServerEnd<DeviceControllerMarker>,
        type_: DeviceType,
        local_device_id: u64,
        responder: DriverHostControllerCreateDeviceResponder,
    },
    /// Request to restart the driver host. Also restarts all children devices and drivers and
    /// rebinds them once the Driver Host has restarted.
    Restart { responder: DriverHostControllerRestartResponder },
}

impl DriverHostControllerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_create_device(
        self,
    ) -> Option<(
        fidl::endpoints::ClientEnd<CoordinatorMarker>,
        fidl::endpoints::ServerEnd<DeviceControllerMarker>,
        DeviceType,
        u64,
        DriverHostControllerCreateDeviceResponder,
    )> {
        if let DriverHostControllerRequest::CreateDevice {
            coordinator,
            device_controller,
            type_,
            local_device_id,
            responder,
        } = self
        {
            Some((coordinator, device_controller, type_, local_device_id, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_restart(self) -> Option<(DriverHostControllerRestartResponder)> {
        if let DriverHostControllerRequest::Restart { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            DriverHostControllerRequest::CreateDevice { .. } => "create_device",
            DriverHostControllerRequest::Restart { .. } => "restart",
        }
    }
}

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

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

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

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }

    fn on_closed<'a>(&'a self) -> fidl::OnSignals<'a> {
        self.inner.channel().on_closed()
    }
}

impl DriverHostControllerControlHandle {}

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

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for SystemStateTransitionMarker {
    type Proxy = SystemStateTransitionProxy;
    type RequestStream = SystemStateTransitionRequestStream;
    const DEBUG_NAME: &'static str = "fuchsia.device.manager.SystemStateTransition";
}
impl fidl::endpoints::DiscoverableProtocolMarker for SystemStateTransitionMarker {}
pub type SystemStateTransitionGetMexecZbisResult = Result<(fidl::Vmo, fidl::Vmo), i32>;

pub trait SystemStateTransitionProxyInterface: Send + Sync {
    type GetTerminationSystemStateResponseFut: std::future::Future<Output = Result<SystemPowerState, fidl::Error>>
        + Send;
    fn r#get_termination_system_state(&self) -> Self::GetTerminationSystemStateResponseFut;
    type GetMexecZbisResponseFut: std::future::Future<Output = Result<SystemStateTransitionGetMexecZbisResult, fidl::Error>>
        + Send;
    fn r#get_mexec_zbis(&self) -> Self::GetMexecZbisResponseFut;
}

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

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

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

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

    /// Gets the termination state.
    pub fn r#get_termination_system_state(
        &self,
        ___deadline: zx::Time,
    ) -> Result<SystemPowerState, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            SystemStateTransitionGetTerminationSystemStateResponse,
        >(
            (),
            0x12161ad87afc0b63,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.state)
    }

    /// When the system termination state is MEXEC, in the course of shutting
    /// down, driver_manager will perform an mexec itself after suspending all
    /// drivers. This method allows driver manager to fetch the kernel and
    /// data ZBIs to be passed to zx_system_mexec().
    ///
    /// This method only should only be invoked in the case MEXEC shutdown.
    ///
    /// It is expected that the ZBI items specified by
    /// `zx_system_mexec_payload_get()` have not yet been appended to the
    /// provided data ZBI.
    ///
    /// Returns
    /// * ZX_ERR_BAD_STATE: The termination system state is not set to MEXEC.
    pub fn r#get_mexec_zbis(
        &self,
        ___deadline: zx::Time,
    ) -> Result<SystemStateTransitionGetMexecZbisResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                SystemStateTransitionGetMexecZbisResponse,
                i32,
            >>(
                (),
                0x1ca6dd89b84f94c7,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| (x.kernel_zbi, x.data_zbi)))
    }
}

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

impl fidl::endpoints::Proxy for SystemStateTransitionProxy {
    type Protocol = SystemStateTransitionMarker;

    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 SystemStateTransitionProxy {
    /// Create a new Proxy for fuchsia.device.manager/SystemStateTransition.
    pub fn new(channel: fidl::AsyncChannel) -> Self {
        let protocol_name =
            <SystemStateTransitionMarker 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) -> SystemStateTransitionEventStream {
        SystemStateTransitionEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Gets the termination state.
    pub fn r#get_termination_system_state(
        &self,
    ) -> fidl::client::QueryResponseFut<SystemPowerState> {
        SystemStateTransitionProxyInterface::r#get_termination_system_state(self)
    }

    /// When the system termination state is MEXEC, in the course of shutting
    /// down, driver_manager will perform an mexec itself after suspending all
    /// drivers. This method allows driver manager to fetch the kernel and
    /// data ZBIs to be passed to zx_system_mexec().
    ///
    /// This method only should only be invoked in the case MEXEC shutdown.
    ///
    /// It is expected that the ZBI items specified by
    /// `zx_system_mexec_payload_get()` have not yet been appended to the
    /// provided data ZBI.
    ///
    /// Returns
    /// * ZX_ERR_BAD_STATE: The termination system state is not set to MEXEC.
    pub fn r#get_mexec_zbis(
        &self,
    ) -> fidl::client::QueryResponseFut<SystemStateTransitionGetMexecZbisResult> {
        SystemStateTransitionProxyInterface::r#get_mexec_zbis(self)
    }
}

impl SystemStateTransitionProxyInterface for SystemStateTransitionProxy {
    type GetTerminationSystemStateResponseFut = fidl::client::QueryResponseFut<SystemPowerState>;
    fn r#get_termination_system_state(&self) -> Self::GetTerminationSystemStateResponseFut {
        fn _decode(
            mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
        ) -> Result<SystemPowerState, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                SystemStateTransitionGetTerminationSystemStateResponse,
                0x12161ad87afc0b63,
            >(_buf?)?;
            Ok(_response.state)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, SystemPowerState>(
            (),
            0x12161ad87afc0b63,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetMexecZbisResponseFut =
        fidl::client::QueryResponseFut<SystemStateTransitionGetMexecZbisResult>;
    fn r#get_mexec_zbis(&self) -> Self::GetMexecZbisResponseFut {
        fn _decode(
            mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
        ) -> Result<SystemStateTransitionGetMexecZbisResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<SystemStateTransitionGetMexecZbisResponse, i32>,
                0x1ca6dd89b84f94c7,
            >(_buf?)?;
            Ok(_response.map(|x| (x.kernel_zbi, x.data_zbi)))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            SystemStateTransitionGetMexecZbisResult,
        >(
            (),
            0x1ca6dd89b84f94c7,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.device.manager/SystemStateTransition.
pub struct SystemStateTransitionRequestStream {
    inner: std::sync::Arc<fidl::ServeInner>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for SystemStateTransitionRequestStream {
    type Protocol = SystemStateTransitionMarker;
    type ControlHandle = SystemStateTransitionControlHandle;

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

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

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

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

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

            std::task::Poll::Ready(Some(match header.ordinal {
                0x12161ad87afc0b63 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
                    fidl::encoding::Decoder::decode_into::<fidl::encoding::EmptyPayload>(
                        &header,
                        _body_bytes,
                        handles,
                        &mut req,
                    )?;
                    let control_handle =
                        SystemStateTransitionControlHandle { inner: this.inner.clone() };
                    Ok(SystemStateTransitionRequest::GetTerminationSystemState {
                        responder: SystemStateTransitionGetTerminationSystemStateResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x1ca6dd89b84f94c7 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
                    fidl::encoding::Decoder::decode_into::<fidl::encoding::EmptyPayload>(
                        &header,
                        _body_bytes,
                        handles,
                        &mut req,
                    )?;
                    let control_handle =
                        SystemStateTransitionControlHandle { inner: this.inner.clone() };
                    Ok(SystemStateTransitionRequest::GetMexecZbis {
                        responder: SystemStateTransitionGetMexecZbisResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name:
                        <SystemStateTransitionMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
        })
    }
}

/// Provides protocol for fetching relevant information during a system state transition.
#[derive(Debug)]
pub enum SystemStateTransitionRequest {
    /// Gets the termination state.
    GetTerminationSystemState { responder: SystemStateTransitionGetTerminationSystemStateResponder },
    /// When the system termination state is MEXEC, in the course of shutting
    /// down, driver_manager will perform an mexec itself after suspending all
    /// drivers. This method allows driver manager to fetch the kernel and
    /// data ZBIs to be passed to zx_system_mexec().
    ///
    /// This method only should only be invoked in the case MEXEC shutdown.
    ///
    /// It is expected that the ZBI items specified by
    /// `zx_system_mexec_payload_get()` have not yet been appended to the
    /// provided data ZBI.
    ///
    /// Returns
    /// * ZX_ERR_BAD_STATE: The termination system state is not set to MEXEC.
    GetMexecZbis { responder: SystemStateTransitionGetMexecZbisResponder },
}

impl SystemStateTransitionRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_termination_system_state(
        self,
    ) -> Option<(SystemStateTransitionGetTerminationSystemStateResponder)> {
        if let SystemStateTransitionRequest::GetTerminationSystemState { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_mexec_zbis(self) -> Option<(SystemStateTransitionGetMexecZbisResponder)> {
        if let SystemStateTransitionRequest::GetMexecZbis { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            SystemStateTransitionRequest::GetTerminationSystemState { .. } => {
                "get_termination_system_state"
            }
            SystemStateTransitionRequest::GetMexecZbis { .. } => "get_mexec_zbis",
        }
    }
}

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

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

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

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }

    fn on_closed<'a>(&'a self) -> fidl::OnSignals<'a> {
        self.inner.channel().on_closed()
    }
}

impl SystemStateTransitionControlHandle {}

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

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

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

    fn send_raw(&self, mut state: SystemPowerState) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<SystemStateTransitionGetTerminationSystemStateResponse>(
            (state,),
            self.tx_id,
            0x12161ad87afc0b63,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

mod internal {
    use super::*;
    unsafe impl fidl::encoding::TypeMarker for AddDeviceConfig {
        type Owned = Self;

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

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

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

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

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

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

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

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

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

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

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

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

    impl fidl::encoding::Decode<Self> for SystemPowerState {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::FullyOn
        }

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

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }

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

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            104
        }
    }
    impl fidl::encoding::ValueTypeMarker for AddDeviceArgs {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::Encode<AddDeviceArgs> for &AddDeviceArgs {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<AddDeviceArgs>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<AddDeviceArgs>::encode(
                (
                    <fidl::encoding::BoundedString<31> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.protocol_id),
                    <DevicePropertyList as fidl::encoding::ValueTypeMarker>::borrow(&self.property_list),
                    <fidl::encoding::Optional<fidl::encoding::BoundedString<1024>> as fidl::encoding::ValueTypeMarker>::borrow(&self.driver_path),
                    <fidl::encoding::Optional<fidl::encoding::BoundedString<1024>> as fidl::encoding::ValueTypeMarker>::borrow(&self.args),
                    <AddDeviceConfig as fidl::encoding::ValueTypeMarker>::borrow(&self.device_add_config),
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.has_init),
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.dfv2_device_symbol),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<31>>,
            T1: fidl::encoding::Encode<u32>,
            T2: fidl::encoding::Encode<DevicePropertyList>,
            T3: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::BoundedString<1024>>>,
            T4: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::BoundedString<1024>>>,
            T5: fidl::encoding::Encode<AddDeviceConfig>,
            T6: fidl::encoding::Encode<bool>,
            T7: fidl::encoding::Encode<u64>,
        > fidl::encoding::Encode<AddDeviceArgs> for (T0, T1, T2, T3, T4, T5, T6, T7)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<AddDeviceArgs>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
                (ptr as *mut u64).write_unaligned(0);
            }
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(88);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            self.2.encode(encoder, offset + 24, depth)?;
            self.3.encode(encoder, offset + 56, depth)?;
            self.4.encode(encoder, offset + 72, depth)?;
            self.5.encode(encoder, offset + 88, depth)?;
            self.6.encode(encoder, offset + 92, depth)?;
            self.7.encode(encoder, offset + 96, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self> for AddDeviceArgs {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                name: fidl::new_empty!(fidl::encoding::BoundedString<31>),
                protocol_id: fidl::new_empty!(u32),
                property_list: fidl::new_empty!(DevicePropertyList),
                driver_path: fidl::new_empty!(
                    fidl::encoding::Optional<fidl::encoding::BoundedString<1024>>
                ),
                args: fidl::new_empty!(
                    fidl::encoding::Optional<fidl::encoding::BoundedString<1024>>
                ),
                device_add_config: fidl::new_empty!(AddDeviceConfig),
                has_init: fidl::new_empty!(bool),
                dfv2_device_symbol: fidl::new_empty!(u64),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let maskedval = padval & 0xffffffff00000000u64;
            if (maskedval != 0) {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset
                        + 16
                        + ((0xffffffff00000000u64 as u64).trailing_zeros() / 8) as usize,
                });
            }
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(88) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let maskedval = padval & 0xffffff0000000000u64;
            if (maskedval != 0) {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset
                        + 88
                        + ((0xffffff0000000000u64 as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl::encoding::BoundedString<31>,
                &mut self.name,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(u32, &mut self.protocol_id, decoder, offset + 16, _depth)?;
            fidl::decode!(
                DevicePropertyList,
                &mut self.property_list,
                decoder,
                offset + 24,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Optional<fidl::encoding::BoundedString<1024>>,
                &mut self.driver_path,
                decoder,
                offset + 56,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Optional<fidl::encoding::BoundedString<1024>>,
                &mut self.args,
                decoder,
                offset + 72,
                _depth
            )?;
            fidl::decode!(
                AddDeviceConfig,
                &mut self.device_add_config,
                decoder,
                offset + 88,
                _depth
            )?;
            fidl::decode!(bool, &mut self.has_init, decoder, offset + 92, _depth)?;
            fidl::decode!(u64, &mut self.dfv2_device_symbol, decoder, offset + 96, _depth)?;
            Ok(())
        }
    }

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

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

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

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

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

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
            }
            Ok(())
        }
    }

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

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

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

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

    unsafe impl fidl::encoding::Encode<BindInstruction> for &BindInstruction {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<BindInstruction>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut BindInstruction)
                    .write_unaligned((self as *const BindInstruction).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
            }
            Ok(())
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<u32>,
            T1: fidl::encoding::Encode<u32>,
            T2: fidl::encoding::Encode<u32>,
        > fidl::encoding::Encode<BindInstruction> for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<BindInstruction>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            self.2.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self> for BindInstruction {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                op: fidl::new_empty!(u32),
                arg: fidl::new_empty!(u32),
                debug: fidl::new_empty!(u32),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 12);
            }
            Ok(())
        }
    }

    unsafe impl fidl::encoding::TypeMarker for CompositeDevice {
        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
        }
    }
    impl fidl::encoding::ValueTypeMarker for CompositeDevice {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::Encode<CompositeDevice> for &CompositeDevice {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CompositeDevice>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<CompositeDevice>::encode(
                (
                    <fidl::encoding::Vector<Fragment, 16> as fidl::encoding::ValueTypeMarker>::borrow(&self.fragments),
                    <fidl::encoding::BoundedString<31> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<fidl::encoding::Vector<Fragment, 16>>,
            T1: fidl::encoding::Encode<fidl::encoding::BoundedString<31>>,
        > fidl::encoding::Encode<CompositeDevice> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CompositeDevice>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self> for CompositeDevice {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                fragments: fidl::new_empty!(fidl::encoding::Vector<Fragment, 16>),
                name: fidl::new_empty!(fidl::encoding::BoundedString<31>),
            }
        }

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

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

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            72
        }
    }
    impl fidl::encoding::ValueTypeMarker for CompositeDeviceDescriptor {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::Encode<CompositeDeviceDescriptor> for &CompositeDeviceDescriptor {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CompositeDeviceDescriptor>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<CompositeDeviceDescriptor>::encode(
                (
                    <fidl::encoding::Vector<DeviceProperty, 256> as fidl::encoding::ValueTypeMarker>::borrow(&self.props),
                    <fidl::encoding::Vector<DeviceStrProperty, 256> as fidl::encoding::ValueTypeMarker>::borrow(&self.str_props),
                    <fidl::encoding::Vector<DeviceFragment, 16> as fidl::encoding::ValueTypeMarker>::borrow(&self.fragments),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.primary_fragment_index),
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.spawn_colocated),
                    <fidl::encoding::Optional<fidl::encoding::Vector<DeviceMetadata, 32>> as fidl::encoding::ValueTypeMarker>::borrow(&self.metadata),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<fidl::encoding::Vector<DeviceProperty, 256>>,
            T1: fidl::encoding::Encode<fidl::encoding::Vector<DeviceStrProperty, 256>>,
            T2: fidl::encoding::Encode<fidl::encoding::Vector<DeviceFragment, 16>>,
            T3: fidl::encoding::Encode<u32>,
            T4: fidl::encoding::Encode<bool>,
            T5: fidl::encoding::Encode<
                fidl::encoding::Optional<fidl::encoding::Vector<DeviceMetadata, 32>>,
            >,
        > fidl::encoding::Encode<CompositeDeviceDescriptor> for (T0, T1, T2, T3, T4, T5)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CompositeDeviceDescriptor>(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(48);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            self.2.encode(encoder, offset + 32, depth)?;
            self.3.encode(encoder, offset + 48, depth)?;
            self.4.encode(encoder, offset + 52, depth)?;
            self.5.encode(encoder, offset + 56, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self> for CompositeDeviceDescriptor {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                props: fidl::new_empty!(fidl::encoding::Vector<DeviceProperty, 256>),
                str_props: fidl::new_empty!(fidl::encoding::Vector<DeviceStrProperty, 256>),
                fragments: fidl::new_empty!(fidl::encoding::Vector<DeviceFragment, 16>),
                primary_fragment_index: fidl::new_empty!(u32),
                spawn_colocated: fidl::new_empty!(bool),
                metadata: fidl::new_empty!(
                    fidl::encoding::Optional<fidl::encoding::Vector<DeviceMetadata, 32>>
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_>,
            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(48) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let maskedval = padval & 0xffffff0000000000u64;
            if (maskedval != 0) {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset
                        + 48
                        + ((0xffffff0000000000u64 as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(fidl::encoding::Vector<DeviceProperty, 256>, &mut self.props, decoder, offset + 0, _depth)?;
            fidl::decode!(fidl::encoding::Vector<DeviceStrProperty, 256>, &mut self.str_props, decoder, offset + 16, _depth)?;
            fidl::decode!(fidl::encoding::Vector<DeviceFragment, 16>, &mut self.fragments, decoder, offset + 32, _depth)?;
            fidl::decode!(u32, &mut self.primary_fragment_index, decoder, offset + 48, _depth)?;
            fidl::decode!(bool, &mut self.spawn_colocated, decoder, offset + 52, _depth)?;
            fidl::decode!(
                fidl::encoding::Optional<fidl::encoding::Vector<DeviceMetadata, 32>>,
                &mut self.metadata,
                decoder,
                offset + 56,
                _depth
            )?;
            Ok(())
        }
    }

    unsafe impl fidl::encoding::TypeMarker for CompositeNodeSpecDescriptor {
        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
        }
    }
    impl fidl::encoding::ValueTypeMarker for CompositeNodeSpecDescriptor {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::Encode<CompositeNodeSpecDescriptor> for &CompositeNodeSpecDescriptor {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CompositeNodeSpecDescriptor>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<CompositeNodeSpecDescriptor>::encode(
                (
                    <fidl::encoding::UnboundedVector<fidl_fuchsia_driver_framework::ParentSpec> as fidl::encoding::ValueTypeMarker>::borrow(&self.parents),
                    <fidl::encoding::Optional<fidl::encoding::Vector<DeviceMetadata, 32>> as fidl::encoding::ValueTypeMarker>::borrow(&self.metadata),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::UnboundedVector<fidl_fuchsia_driver_framework::ParentSpec>,
            >,
            T1: fidl::encoding::Encode<
                fidl::encoding::Optional<fidl::encoding::Vector<DeviceMetadata, 32>>,
            >,
        > fidl::encoding::Encode<CompositeNodeSpecDescriptor> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CompositeNodeSpecDescriptor>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self> for CompositeNodeSpecDescriptor {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                parents: fidl::new_empty!(
                    fidl::encoding::UnboundedVector<fidl_fuchsia_driver_framework::ParentSpec>
                ),
                metadata: fidl::new_empty!(
                    fidl::encoding::Optional<fidl::encoding::Vector<DeviceMetadata, 32>>
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::UnboundedVector<fidl_fuchsia_driver_framework::ParentSpec>,
                &mut self.parents,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Optional<fidl::encoding::Vector<DeviceMetadata, 32>>,
                &mut self.metadata,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

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

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            88
        }
    }
    impl fidl::encoding::ValueTypeMarker for CoordinatorAddCompositeDeviceRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::Encode<CoordinatorAddCompositeDeviceRequest>
        for &CoordinatorAddCompositeDeviceRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CoordinatorAddCompositeDeviceRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<CoordinatorAddCompositeDeviceRequest>::encode(
                (
                    <fidl::encoding::BoundedString<31> as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.name,
                    ),
                    <CompositeDeviceDescriptor as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.comp_desc,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<31>>,
            T1: fidl::encoding::Encode<CompositeDeviceDescriptor>,
        > fidl::encoding::Encode<CoordinatorAddCompositeDeviceRequest> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CoordinatorAddCompositeDeviceRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self> for CoordinatorAddCompositeDeviceRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                name: fidl::new_empty!(fidl::encoding::BoundedString<31>),
                comp_desc: fidl::new_empty!(CompositeDeviceDescriptor),
            }
        }

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

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

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            48
        }
    }
    impl fidl::encoding::ValueTypeMarker for CoordinatorAddCompositeNodeSpecRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::Encode<CoordinatorAddCompositeNodeSpecRequest>
        for &CoordinatorAddCompositeNodeSpecRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CoordinatorAddCompositeNodeSpecRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<CoordinatorAddCompositeNodeSpecRequest>::encode(
                (
                    <fidl::encoding::BoundedString<31> as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.name,
                    ),
                    <CompositeNodeSpecDescriptor as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.spec,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<31>>,
            T1: fidl::encoding::Encode<CompositeNodeSpecDescriptor>,
        > fidl::encoding::Encode<CoordinatorAddCompositeNodeSpecRequest> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CoordinatorAddCompositeNodeSpecRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self> for CoordinatorAddCompositeNodeSpecRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                name: fidl::new_empty!(fidl::encoding::BoundedString<31>),
                spec: fidl::new_empty!(CompositeNodeSpecDescriptor),
            }
        }

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

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

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            120
        }
    }
    impl fidl::encoding::ResourceTypeMarker for CoordinatorAddDeviceRequest {
        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::Encode<CoordinatorAddDeviceRequest>
        for &mut CoordinatorAddDeviceRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CoordinatorAddDeviceRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<CoordinatorAddDeviceRequest>::encode(
                (
                    <AddDeviceArgs as fidl::encoding::ValueTypeMarker>::borrow(&self.args),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<CoordinatorMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.coordinator),
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<DeviceControllerMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.device_controller),
                    <fidl::encoding::Optional<fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.inspect),
                    <fidl::encoding::Optional<fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.outgoing_dir),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<AddDeviceArgs>,
            T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<CoordinatorMarker>>,
            >,
            T2: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<DeviceControllerMarker>>,
            >,
            T3: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fidl::Vmo,
                        { fidl::ObjectType::VMO.into_raw() },
                        2147483648,
                    >,
                >,
            >,
            T4: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
                    >,
                >,
            >,
        > fidl::encoding::Encode<CoordinatorAddDeviceRequest> for (T0, T1, T2, T3, T4)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CoordinatorAddDeviceRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 104, depth)?;
            self.2.encode(encoder, offset + 108, depth)?;
            self.3.encode(encoder, offset + 112, depth)?;
            self.4.encode(encoder, offset + 116, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self> for CoordinatorAddDeviceRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                args: fidl::new_empty!(AddDeviceArgs),
                coordinator: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<CoordinatorMarker>>
                ),
                device_controller: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<DeviceControllerMarker>>
                ),
                inspect: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fidl::Vmo,
                            { fidl::ObjectType::VMO.into_raw() },
                            2147483648,
                        >,
                    >
                ),
                outgoing_dir: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::Endpoint<
                            fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
                        >,
                    >
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(AddDeviceArgs, &mut self.args, decoder, offset + 0, _depth)?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<CoordinatorMarker>>,
                &mut self.coordinator,
                decoder,
                offset + 104,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<DeviceControllerMarker>>,
                &mut self.device_controller,
                decoder,
                offset + 108,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fidl::Vmo,
                        { fidl::ObjectType::VMO.into_raw() },
                        2147483648,
                    >,
                >,
                &mut self.inspect,
                decoder,
                offset + 112,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
                    >,
                >,
                &mut self.outgoing_dir,
                decoder,
                offset + 116,
                _depth
            )?;
            Ok(())
        }
    }

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

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            24
        }
    }
    impl fidl::encoding::ValueTypeMarker for CoordinatorAddMetadataRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

    impl fidl::encoding::Decode<Self> for CoordinatorAddMetadataRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                key: fidl::new_empty!(u32),
                data: fidl::new_empty!(fidl::encoding::Optional<fidl::encoding::Vector<u8, 8192>>),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_>,
            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 maskedval = padval & 0xffffffff00000000u64;
            if (maskedval != 0) {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset
                        + 0
                        + ((0xffffffff00000000u64 as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(u32, &mut self.key, decoder, offset + 0, _depth)?;
            fidl::decode!(
                fidl::encoding::Optional<fidl::encoding::Vector<u8, 8192>>,
                &mut self.data,
                decoder,
                offset + 8,
                _depth
            )?;
            Ok(())
        }
    }

    unsafe impl fidl::encoding::TypeMarker for CoordinatorBindDeviceRequest {
        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
        }
    }
    impl fidl::encoding::ValueTypeMarker for CoordinatorBindDeviceRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

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

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            56
        }
    }
    impl fidl::encoding::ResourceTypeMarker for CoordinatorConnectFidlProtocolRequest {
        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::Encode<CoordinatorConnectFidlProtocolRequest>
        for &mut CoordinatorConnectFidlProtocolRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CoordinatorConnectFidlProtocolRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<CoordinatorConnectFidlProtocolRequest>::encode(
                (
                    <fidl::encoding::Optional<fidl::encoding::BoundedString<31>> as fidl::encoding::ValueTypeMarker>::borrow(&self.fragment_name),
                    <fidl::encoding::Optional<fidl::encoding::BoundedString<255>> as fidl::encoding::ValueTypeMarker>::borrow(&self.service_name),
                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(&self.protocol_name),
                    <fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.server),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::BoundedString<31>>>,
            T1: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::BoundedString<255>>>,
            T2: fidl::encoding::Encode<fidl::encoding::BoundedString<255>>,
            T3: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::Channel,
                    { fidl::ObjectType::CHANNEL.into_raw() },
                    2147483648,
                >,
            >,
        > fidl::encoding::Encode<CoordinatorConnectFidlProtocolRequest> for (T0, T1, T2, T3)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CoordinatorConnectFidlProtocolRequest>(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(48);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            self.2.encode(encoder, offset + 32, depth)?;
            self.3.encode(encoder, offset + 48, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self> for CoordinatorConnectFidlProtocolRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                fragment_name: fidl::new_empty!(
                    fidl::encoding::Optional<fidl::encoding::BoundedString<31>>
                ),
                service_name: fidl::new_empty!(
                    fidl::encoding::Optional<fidl::encoding::BoundedString<255>>
                ),
                protocol_name: fidl::new_empty!(fidl::encoding::BoundedString<255>),
                server: fidl::new_empty!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_>,
            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(48) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let maskedval = padval & 0xffffffff00000000u64;
            if (maskedval != 0) {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset
                        + 48
                        + ((0xffffffff00000000u64 as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl::encoding::Optional<fidl::encoding::BoundedString<31>>,
                &mut self.fragment_name,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Optional<fidl::encoding::BoundedString<255>>,
                &mut self.service_name,
                decoder,
                offset + 16,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::BoundedString<255>,
                &mut self.protocol_name,
                decoder,
                offset + 32,
                _depth
            )?;
            fidl::decode!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, &mut self.server, decoder, offset + 48, _depth)?;
            Ok(())
        }
    }

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

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

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

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

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

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
            }
            Ok(())
        }
    }

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

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

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

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

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

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
            }
            Ok(())
        }
    }

    unsafe impl fidl::encoding::TypeMarker for CoordinatorLoadFirmwareRequest {
        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
        }
    }
    impl fidl::encoding::ValueTypeMarker for CoordinatorLoadFirmwareRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::Encode<CoordinatorLoadFirmwareRequest>
        for &CoordinatorLoadFirmwareRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CoordinatorLoadFirmwareRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<CoordinatorLoadFirmwareRequest>::encode(
                (
                    <fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow(&self.driver_path),
                    <fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow(&self.fw_path),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<1024>>,
            T1: fidl::encoding::Encode<fidl::encoding::BoundedString<1024>>,
        > fidl::encoding::Encode<CoordinatorLoadFirmwareRequest> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CoordinatorLoadFirmwareRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self> for CoordinatorLoadFirmwareRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                driver_path: fidl::new_empty!(fidl::encoding::BoundedString<1024>),
                fw_path: fidl::new_empty!(fidl::encoding::BoundedString<1024>),
            }
        }

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

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

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            1
        }
    }
    impl fidl::encoding::ValueTypeMarker for CoordinatorScheduleRemoveRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

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

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

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

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

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

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
            }
            Ok(())
        }
    }

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

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

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

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

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

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
            }
            Ok(())
        }
    }

    unsafe impl fidl::encoding::TypeMarker for CoordinatorGetMetadataResponse {
        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
        }
    }
    impl fidl::encoding::ValueTypeMarker for CoordinatorGetMetadataResponse {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

    unsafe impl fidl::encoding::TypeMarker for CoordinatorGetTopologicalPathResponse {
        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
        }
    }
    impl fidl::encoding::ValueTypeMarker for CoordinatorGetTopologicalPathResponse {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

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

    impl fidl::encoding::Decode<Self> for CoordinatorLoadFirmwareResponse {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                vmo: fidl::new_empty!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>),
                size: fidl::new_empty!(u64),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_>,
            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 maskedval = padval & 0xffffffff00000000u64;
            if (maskedval != 0) {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset
                        + 0
                        + ((0xffffffff00000000u64 as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, &mut self.vmo, decoder, offset + 0, _depth)?;
            fidl::decode!(u64, &mut self.size, decoder, offset + 8, _depth)?;
            Ok(())
        }
    }

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

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            1
        }
    }
    impl fidl::encoding::ValueTypeMarker for CoordinatorScheduleUnbindChildrenResponse {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

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

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            40
        }
    }
    impl fidl::encoding::ResourceTypeMarker for DeviceControllerBindDriverRequest {
        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::Encode<DeviceControllerBindDriverRequest>
        for &mut DeviceControllerBindDriverRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceControllerBindDriverRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DeviceControllerBindDriverRequest>::encode(
                (
                    <fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow(&self.driver_path),
                    <fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.driver),
                    <fidl::encoding::BoundedString<2048> as fidl::encoding::ValueTypeMarker>::borrow(&self.default_dispatcher_scheduler_role),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<1024>>,
            T1: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::Vmo,
                    { fidl::ObjectType::VMO.into_raw() },
                    2147483648,
                >,
            >,
            T2: fidl::encoding::Encode<fidl::encoding::BoundedString<2048>>,
        > fidl::encoding::Encode<DeviceControllerBindDriverRequest> for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceControllerBindDriverRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            self.2.encode(encoder, offset + 24, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self> for DeviceControllerBindDriverRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                driver_path: fidl::new_empty!(fidl::encoding::BoundedString<1024>),
                driver: fidl::new_empty!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>),
                default_dispatcher_scheduler_role: fidl::new_empty!(
                    fidl::encoding::BoundedString<2048>
                ),
            }
        }

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

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

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            8
        }
    }
    impl fidl::encoding::ResourceTypeMarker for DeviceControllerBindDriverResponse {
        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::Encode<DeviceControllerBindDriverResponse>
        for &mut DeviceControllerBindDriverResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceControllerBindDriverResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DeviceControllerBindDriverResponse>::encode(
                (
                    <i32 as fidl::encoding::ValueTypeMarker>::borrow(&self.status),
                    <fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fidl::Channel,
                            { fidl::ObjectType::CHANNEL.into_raw() },
                            2147483648,
                        >,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.test_output
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<i32>,
            T1: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fidl::Channel,
                        { fidl::ObjectType::CHANNEL.into_raw() },
                        2147483648,
                    >,
                >,
            >,
        > fidl::encoding::Encode<DeviceControllerBindDriverResponse> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceControllerBindDriverResponse>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self> for DeviceControllerBindDriverResponse {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                status: fidl::new_empty!(i32),
                test_output: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fidl::Channel,
                            { fidl::ObjectType::CHANNEL.into_raw() },
                            2147483648,
                        >,
                    >
                ),
            }
        }

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

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

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            8
        }
    }
    impl fidl::encoding::ResourceTypeMarker for DeviceControllerConnectMultiplexedRequest {
        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::Encode<DeviceControllerConnectMultiplexedRequest>
        for &mut DeviceControllerConnectMultiplexedRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceControllerConnectMultiplexedRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DeviceControllerConnectMultiplexedRequest>::encode(
                (
                    <fidl::encoding::HandleType<
                        fidl::Channel,
                        { fidl::ObjectType::CHANNEL.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.server
                    ),
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.include_node),
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.include_controller),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::Channel,
                    { fidl::ObjectType::CHANNEL.into_raw() },
                    2147483648,
                >,
            >,
            T1: fidl::encoding::Encode<bool>,
            T2: fidl::encoding::Encode<bool>,
        > fidl::encoding::Encode<DeviceControllerConnectMultiplexedRequest> for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceControllerConnectMultiplexedRequest>(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(4);
                (ptr as *mut u32).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            self.2.encode(encoder, offset + 5, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self> for DeviceControllerConnectMultiplexedRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                server: fidl::new_empty!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>),
                include_node: fidl::new_empty!(bool),
                include_controller: fidl::new_empty!(bool),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_>,
            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(4) };
            let padval = unsafe { (ptr as *const u32).read_unaligned() };
            let maskedval = padval & 0xffff0000u32;
            if (maskedval != 0) {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset
                        + 4
                        + ((0xffff0000u32 as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, &mut self.server, decoder, offset + 0, _depth)?;
            fidl::decode!(bool, &mut self.include_node, decoder, offset + 4, _depth)?;
            fidl::decode!(bool, &mut self.include_controller, decoder, offset + 5, _depth)?;
            Ok(())
        }
    }

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

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            4
        }
    }
    impl fidl::encoding::ResourceTypeMarker for DeviceControllerConnectProxyRequest {
        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::Encode<DeviceControllerConnectProxyRequest>
        for &mut DeviceControllerConnectProxyRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceControllerConnectProxyRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DeviceControllerConnectProxyRequest>::encode(
                (<fidl::encoding::HandleType<
                    fidl::Channel,
                    { fidl::ObjectType::CHANNEL.into_raw() },
                    2147483648,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.shadow
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::Channel,
                    { fidl::ObjectType::CHANNEL.into_raw() },
                    2147483648,
                >,
            >,
        > fidl::encoding::Encode<DeviceControllerConnectProxyRequest> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceControllerConnectProxyRequest>(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> for DeviceControllerConnectProxyRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                shadow: fidl::new_empty!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>),
            }
        }

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

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

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

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

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

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

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            4
        }
    }
    impl fidl::encoding::ResourceTypeMarker for DeviceControllerConnectToDeviceProtocolRequest {
        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::Encode<DeviceControllerConnectToDeviceProtocolRequest>
        for &mut DeviceControllerConnectToDeviceProtocolRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceControllerConnectToDeviceProtocolRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DeviceControllerConnectToDeviceProtocolRequest>::encode(
                (<fidl::encoding::HandleType<
                    fidl::Channel,
                    { fidl::ObjectType::CHANNEL.into_raw() },
                    2147483648,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.server
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::Channel,
                    { fidl::ObjectType::CHANNEL.into_raw() },
                    2147483648,
                >,
            >,
        > fidl::encoding::Encode<DeviceControllerConnectToDeviceProtocolRequest> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceControllerConnectToDeviceProtocolRequest>(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> for DeviceControllerConnectToDeviceProtocolRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                server: fidl::new_empty!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>),
            }
        }

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

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

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

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

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

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

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
            }
            Ok(())
        }
    }

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

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

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

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

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

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
            }
            Ok(())
        }
    }

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

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

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

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

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

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
            }
            Ok(())
        }
    }

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

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

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

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

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

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
            }
            Ok(())
        }
    }

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

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

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

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

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

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
            }
            Ok(())
        }
    }

    unsafe impl fidl::encoding::TypeMarker for DeviceFragment {
        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
        }
    }
    impl fidl::encoding::ValueTypeMarker for DeviceFragment {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::Encode<DeviceFragment> for &DeviceFragment {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceFragment>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DeviceFragment>::encode(
                (
                    <fidl::encoding::BoundedString<32> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
                    <fidl::encoding::Vector<DeviceFragmentPart, 16> as fidl::encoding::ValueTypeMarker>::borrow(&self.parts),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<32>>,
            T1: fidl::encoding::Encode<fidl::encoding::Vector<DeviceFragmentPart, 16>>,
        > fidl::encoding::Encode<DeviceFragment> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceFragment>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self> for DeviceFragment {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                name: fidl::new_empty!(fidl::encoding::BoundedString<32>),
                parts: fidl::new_empty!(fidl::encoding::Vector<DeviceFragmentPart, 16>),
            }
        }

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

    unsafe impl fidl::encoding::TypeMarker for DeviceFragmentPart {
        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
        }
    }
    impl fidl::encoding::ValueTypeMarker for DeviceFragmentPart {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

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

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            24
        }
    }
    impl fidl::encoding::ValueTypeMarker for DeviceMetadata {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

    impl fidl::encoding::Decode<Self> for DeviceMetadata {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                key: fidl::new_empty!(u32),
                data: fidl::new_empty!(fidl::encoding::Vector<u8, 8192>),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_>,
            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 maskedval = padval & 0xffffffff00000000u64;
            if (maskedval != 0) {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset
                        + 0
                        + ((0xffffffff00000000u64 as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(u32, &mut self.key, decoder, offset + 0, _depth)?;
            fidl::decode!(fidl::encoding::Vector<u8, 8192>, &mut self.data, decoder, offset + 8, _depth)?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl fidl::encoding::Encode<DeviceProperty> for &DeviceProperty {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceProperty>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut DeviceProperty)
                    .write_unaligned((self as *const DeviceProperty).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
            }
            Ok(())
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<u16>,
            T1: fidl::encoding::Encode<u16>,
            T2: fidl::encoding::Encode<u32>,
        > fidl::encoding::Encode<DeviceProperty> for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceProperty>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 2, depth)?;
            self.2.encode(encoder, offset + 4, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self> for DeviceProperty {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                id: fidl::new_empty!(u16),
                reserved: fidl::new_empty!(u16),
                value: fidl::new_empty!(u32),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
            }
            Ok(())
        }
    }

    unsafe impl fidl::encoding::TypeMarker for DevicePropertyList {
        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
        }
    }
    impl fidl::encoding::ValueTypeMarker for DevicePropertyList {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::Encode<DevicePropertyList> for &DevicePropertyList {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DevicePropertyList>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DevicePropertyList>::encode(
                (
                    <fidl::encoding::Vector<DeviceProperty, 256> as fidl::encoding::ValueTypeMarker>::borrow(&self.props),
                    <fidl::encoding::Vector<DeviceStrProperty, 256> as fidl::encoding::ValueTypeMarker>::borrow(&self.str_props),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<fidl::encoding::Vector<DeviceProperty, 256>>,
            T1: fidl::encoding::Encode<fidl::encoding::Vector<DeviceStrProperty, 256>>,
        > fidl::encoding::Encode<DevicePropertyList> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DevicePropertyList>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self> for DevicePropertyList {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                props: fidl::new_empty!(fidl::encoding::Vector<DeviceProperty, 256>),
                str_props: fidl::new_empty!(fidl::encoding::Vector<DeviceStrProperty, 256>),
            }
        }

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

    unsafe impl fidl::encoding::TypeMarker for DeviceStrProperty {
        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
        }
    }
    impl fidl::encoding::ValueTypeMarker for DeviceStrProperty {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::Encode<DeviceStrProperty> for &DeviceStrProperty {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceStrProperty>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DeviceStrProperty>::encode(
                (
                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.key,
                    ),
                    <PropertyValue as fidl::encoding::ValueTypeMarker>::borrow(&self.value),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<255>>,
            T1: fidl::encoding::Encode<PropertyValue>,
        > fidl::encoding::Encode<DeviceStrProperty> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceStrProperty>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self> for DeviceStrProperty {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                key: fidl::new_empty!(fidl::encoding::BoundedString<255>),
                value: fidl::new_empty!(PropertyValue),
            }
        }

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

    unsafe impl fidl::encoding::TypeMarker for DriverHostControllerCreateDeviceRequest {
        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
        }
    }
    impl fidl::encoding::ResourceTypeMarker for DriverHostControllerCreateDeviceRequest {
        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::Encode<DriverHostControllerCreateDeviceRequest>
        for &mut DriverHostControllerCreateDeviceRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DriverHostControllerCreateDeviceRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DriverHostControllerCreateDeviceRequest>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<CoordinatorMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.coordinator),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<DeviceControllerMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.device_controller),
                    <DeviceType as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.type_),
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.local_device_id),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<CoordinatorMarker>>,
            >,
            T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<DeviceControllerMarker>>,
            >,
            T2: fidl::encoding::Encode<DeviceType>,
            T3: fidl::encoding::Encode<u64>,
        > fidl::encoding::Encode<DriverHostControllerCreateDeviceRequest> for (T0, T1, T2, T3)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DriverHostControllerCreateDeviceRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            self.2.encode(encoder, offset + 8, depth)?;
            self.3.encode(encoder, offset + 24, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self> for DriverHostControllerCreateDeviceRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                coordinator: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<CoordinatorMarker>>
                ),
                device_controller: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<DeviceControllerMarker>>
                ),
                type_: fidl::new_empty!(DeviceType),
                local_device_id: fidl::new_empty!(u64),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<CoordinatorMarker>>,
                &mut self.coordinator,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<DeviceControllerMarker>>,
                &mut self.device_controller,
                decoder,
                offset + 4,
                _depth
            )?;
            fidl::decode!(DeviceType, &mut self.type_, decoder, offset + 8, _depth)?;
            fidl::decode!(u64, &mut self.local_device_id, decoder, offset + 24, _depth)?;
            Ok(())
        }
    }

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

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

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

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

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