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

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

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

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

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

const _FIDL_TRACE_BINDINGS_RUST: u32 = 6;
bitflags! {
    /// Bit flags for device add configuration
    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
    }
}

fidl_bits! {
    name: AddDeviceConfig,
    prim_ty: u32,
    strict: true,
}

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;

/// 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;

#[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
    }
}

fidl_enum! {
    name: SystemPowerState,
    prim_ty: u8,
    strict: true,
    min_member: FullyOn,
}

pub type CoordinatorAddDeviceResult = Result<(u64), i32>;

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

pub type CoordinatorScheduleUnbindChildrenResult = Result<(bool), i32>;

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

pub type CoordinatorBindDeviceResult = Result<(), i32>;

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

pub type CoordinatorGetTopologicalPathResult = Result<(String), i32>;

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

pub type CoordinatorLoadFirmwareResult = Result<(fidl::Vmo, u64), i32>;

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

pub type CoordinatorGetMetadataResult = Result<(Vec<u8>), i32>;

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

pub type CoordinatorGetMetadataSizeResult = Result<(u64), i32>;

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

pub type CoordinatorAddMetadataResult = Result<(), i32>;

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

pub type CoordinatorAddCompositeDeviceResult = Result<(), i32>;

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

pub type CoordinatorAddCompositeNodeSpecResult = Result<(), i32>;

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

pub type CoordinatorConnectFidlProtocolResult = Result<(), i32>;

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

pub type DeviceControllerUnbindResult = Result<(), i32>;

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

pub type DeviceControllerCompleteRemovalResult = Result<(), i32>;

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

pub type DeviceWatcherNextDeviceResult = Result<(fidl::Channel), i32>;

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

pub type SystemStateTransitionGetMexecZbisResult = Result<(fidl::Vmo, fidl::Vmo), i32>;

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

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
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::encoding::TopLevel for DeviceType {}

fidl_union! {
    name: DeviceType,
    members: [
        Stub {
            ty: StubDevice,
            ordinal: 1,
        },
        Proxy {
            ty: ProxyDevice,
            ordinal: 2,
        },
        FidlProxy {
            ty: FidlProxyDevice,
            ordinal: 3,
        },
        Composite {
            ty: CompositeDevice,
            ordinal: 4,
        },
    ],
}

#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
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::encoding::TopLevel for PropertyValue {}

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

fidl_union! {
    name: PropertyValue,
    members: [
        IntValue {
            ty: u32,
            ordinal: 1,
        },
        StrValue {
            ty: String,
            ordinal: 2,
        },
        BoolValue {
            ty: bool,
            ordinal: 3,
        },
        EnumValue {
            ty: String,
            ordinal: 4,
        },
    ],
}

/// This struct holds non-resource arguments for creating a new device with the
/// Coordinator.
#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
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::encoding::TopLevel for AddDeviceArgs {}

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

fidl_struct! {
    name: AddDeviceArgs,
    members: [
        name {
            ty: String,
            offset_v1: 0,
            offset_v2: 0,
        },
        protocol_id {
            ty: u32,
            offset_v1: 16,
            offset_v2: 16,
        },
        property_list {
            ty: DevicePropertyList,
            offset_v1: 24,
            offset_v2: 24,
        },
        driver_path {
            ty: Option<String>,
            offset_v1: 56,
            offset_v2: 56,
        },
        args {
            ty: Option<String>,
            offset_v1: 72,
            offset_v2: 72,
        },
        device_add_config {
            ty: AddDeviceConfig,
            offset_v1: 88,
            offset_v2: 88,
        },
        has_init {
            ty: bool,
            offset_v1: 92,
            offset_v2: 92,
        },
        dfv2_device_symbol {
            ty: u64,
            offset_v1: 96,
            offset_v2: 96,
        },
    ],
    padding_v1: [
        {
            ty: u64,
            offset: 16,
            mask: 0xffffffff00000000u64,
        },
        {
            ty: u64,
            offset: 88,
            mask: 0xffffff0000000000u64,
        },],
    padding_v2: [
        {
            ty: u64,
            offset: 16,
            mask: 0xffffffff00000000u64,
        },
        {
            ty: u64,
            offset: 88,
            mask: 0xffffff0000000000u64,
        },],
    size_v1: 104,
    size_v2: 104,
    align_v1: 8,
    align_v2: 8,
}

#[derive(
    Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, zerocopy::AsBytes, zerocopy::FromBytes,
)]
#[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::encoding::TopLevel for BindInstruction {}

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

fidl_struct_copy! {
    name: BindInstruction,
    members: [
        op {
            ty: u32,
            offset_v1: 0,
            offset_v2: 0,
        },
        arg {
            ty: u32,
            offset_v1: 4,
            offset_v2: 4,
        },
        debug {
            ty: u32,
            offset_v1: 8,
            offset_v2: 8,
        },
    ],
    padding_v1: [],
    padding_v2: [],
    size_v1: 12,
    size_v2: 12,
    align_v1: 4,
    align_v2: 4,
}

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

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

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

fidl_struct! {
    name: CompositeDevice,
    members: [
        fragments {
            ty: Vec<Fragment>,
            offset_v1: 0,
            offset_v2: 0,
        },
        name {
            ty: String,
            offset_v1: 16,
            offset_v2: 16,
        },
    ],
    padding_v1: [],
    padding_v2: [],
    size_v1: 32,
    size_v2: 32,
    align_v1: 8,
    align_v2: 8,
}

/// Composite device parts and properties
#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
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::encoding::TopLevel for CompositeDeviceDescriptor {}

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

fidl_struct! {
    name: CompositeDeviceDescriptor,
    members: [
        props {
            ty: Vec<DeviceProperty>,
            offset_v1: 0,
            offset_v2: 0,
        },
        str_props {
            ty: Vec<DeviceStrProperty>,
            offset_v1: 16,
            offset_v2: 16,
        },
        fragments {
            ty: Vec<DeviceFragment>,
            offset_v1: 32,
            offset_v2: 32,
        },
        primary_fragment_index {
            ty: u32,
            offset_v1: 48,
            offset_v2: 48,
        },
        spawn_colocated {
            ty: bool,
            offset_v1: 52,
            offset_v2: 52,
        },
        metadata {
            ty: Option<Vec<DeviceMetadata>>,
            offset_v1: 56,
            offset_v2: 56,
        },
    ],
    padding_v1: [
        {
            ty: u64,
            offset: 48,
            mask: 0xffffff0000000000u64,
        },],
    padding_v2: [
        {
            ty: u64,
            offset: 48,
            mask: 0xffffff0000000000u64,
        },],
    size_v1: 72,
    size_v2: 72,
    align_v1: 8,
    align_v2: 8,
}

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

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

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

fidl_struct! {
    name: CompositeNodeSpecDescriptor,
    members: [
        parents {
            ty: Vec<fidl_fuchsia_driver_framework::ParentSpec>,
            offset_v1: 0,
            offset_v2: 0,
        },
        metadata {
            ty: Option<Vec<DeviceMetadata>>,
            offset_v1: 16,
            offset_v2: 16,
        },
    ],
    padding_v1: [],
    padding_v2: [],
    size_v1: 32,
    size_v2: 32,
    align_v1: 8,
    align_v2: 8,
}

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

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

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

fidl_struct! {
    name: DeviceFragment,
    members: [
        name {
            ty: String,
            offset_v1: 0,
            offset_v2: 0,
        },
        parts {
            ty: Vec<DeviceFragmentPart>,
            offset_v1: 16,
            offset_v2: 16,
        },
    ],
    padding_v1: [],
    padding_v2: [],
    size_v1: 32,
    size_v2: 32,
    align_v1: 8,
    align_v2: 8,
}

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

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

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

fidl_struct! {
    name: DeviceFragmentPart,
    members: [
        match_program {
            ty: Vec<BindInstruction>,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [],
    padding_v2: [],
    size_v1: 16,
    size_v2: 16,
    align_v1: 8,
    align_v2: 8,
}

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

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

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

fidl_struct! {
    name: DeviceMetadata,
    members: [
        key {
            ty: u32,
            offset_v1: 0,
            offset_v2: 0,
        },
        data {
            ty: Vec<u8>,
            offset_v1: 8,
            offset_v2: 8,
        },
    ],
    padding_v1: [
        {
            ty: u64,
            offset: 0,
            mask: 0xffffffff00000000u64,
        },],
    padding_v2: [
        {
            ty: u64,
            offset: 0,
            mask: 0xffffffff00000000u64,
        },],
    size_v1: 24,
    size_v2: 24,
    align_v1: 8,
    align_v2: 8,
}

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

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

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

fidl_struct_copy! {
    name: DeviceProperty,
    members: [
        id {
            ty: u16,
            offset_v1: 0,
            offset_v2: 0,
        },
        reserved {
            ty: u16,
            offset_v1: 2,
            offset_v2: 2,
        },
        value {
            ty: u32,
            offset_v1: 4,
            offset_v2: 4,
        },
    ],
    padding_v1: [],
    padding_v2: [],
    size_v1: 8,
    size_v2: 8,
    align_v1: 4,
    align_v2: 4,
}

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

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

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

fidl_struct! {
    name: DevicePropertyList,
    members: [
        props {
            ty: Vec<DeviceProperty>,
            offset_v1: 0,
            offset_v2: 0,
        },
        str_props {
            ty: Vec<DeviceStrProperty>,
            offset_v1: 16,
            offset_v2: 16,
        },
    ],
    padding_v1: [],
    padding_v2: [],
    size_v1: 32,
    size_v2: 32,
    align_v1: 8,
    align_v2: 8,
}

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

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

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

fidl_struct! {
    name: DeviceStrProperty,
    members: [
        key {
            ty: String,
            offset_v1: 0,
            offset_v2: 0,
        },
        value {
            ty: PropertyValue,
            offset_v1: 16,
            offset_v2: 16,
        },
    ],
    padding_v1: [],
    padding_v2: [],
    size_v1: 40,
    size_v2: 32,
    align_v1: 8,
    align_v2: 8,
}

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
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::encoding::TopLevel for FidlProxyDevice {}

fidl_struct! {
    name: FidlProxyDevice,
    members: [
        incoming_dir {
            ty: Option<fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>>,
            offset_v1: 0,
            offset_v2: 0,
            handle_metadata: {
                handle_subtype: fidl::ObjectType::CHANNEL,
                handle_rights: fidl::Rights::CHANNEL_DEFAULT,
            },
        },
    ],
    padding_v1: [],
    padding_v2: [],
    size_v1: 4,
    size_v2: 4,
    align_v1: 4,
    align_v2: 4,
}

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

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

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

fidl_struct! {
    name: Fragment,
    members: [
        name {
            ty: String,
            offset_v1: 0,
            offset_v2: 0,
        },
        id {
            ty: u64,
            offset_v1: 16,
            offset_v2: 16,
        },
    ],
    padding_v1: [],
    padding_v2: [],
    size_v1: 24,
    size_v2: 24,
    align_v1: 8,
    align_v2: 8,
}

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

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

fidl_struct! {
    name: ProxyDevice,
    members: [
        driver_path {
            ty: String,
            offset_v1: 0,
            offset_v2: 0,
        },
        driver {
            ty: fidl::Vmo,
            offset_v1: 16,
            offset_v2: 16,
            handle_metadata: {
                handle_subtype: fidl::ObjectType::VMO,
                handle_rights: fidl::Rights::from_bits_const(2147483648).unwrap(),
            },
        },
        parent_proxy {
            ty: fidl::Channel,
            offset_v1: 20,
            offset_v2: 20,
            handle_metadata: {
                handle_subtype: fidl::ObjectType::CHANNEL,
                handle_rights: fidl::Rights::from_bits_const(2147483648).unwrap(),
            },
        },
    ],
    padding_v1: [],
    padding_v2: [],
    size_v1: 24,
    size_v2: 24,
    align_v1: 8,
    align_v2: 8,
}

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

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

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

fidl_struct_copy! {
    name: StubDevice,
    members: [
        protocol_id {
            ty: u32,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [],
    padding_v2: [],
    size_v1: 4,
    size_v2: 4,
    align_v1: 4,
    align_v2: 4,
}
wrap_handle_metadata!(
    HandleWrapperObjectTypeCHANNELRights2147483648,
    fidl::ObjectType::CHANNEL,
    fidl::Rights::from_bits_const(2147483648).unwrap()
);

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

wrap_handle_metadata!(
    HandleWrapperObjectTypeVMORights2147483648,
    fidl::ObjectType::VMO,
    fidl::Rights::from_bits_const(2147483648).unwrap()
);

#[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 _value: (i32,) = self.client.send_query::<_, _, false, false>(
            &mut (),
            0x3a423df51409d155,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_value.0)
    }
    /// 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::<_, false>(
            &mut (),
            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 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 Administrator 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 transform(result: Result<(i32,), fidl::Error>) -> Result<(i32), fidl::Error> {
            result.map(|_value| _value.0)
        }
        let send_result = self.client.call_send_raw_query::<_, false>(
            &mut (),
            0x3a423df51409d155,
            fidl::encoding::DynamicFlags::empty(),
        );
        QueryResponseFut(match send_result {
            Ok(res_fut) => future::maybe_done(
                res_fut.and_then(|buf| decode_transaction_body_fut::<_, _, false>(buf, transform)),
            ),
            Err(e) => MaybeDone::Done(Err(e)),
        })
    }
    fn r#suspend_without_exit(&self) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (),
            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>> {
        let buf = match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => buf,
            None => return std::task::Poll::Ready(None),
        };

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

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

impl AdministratorEvent {
    /// Decodes a message buffer as a [`AdministratorEvent`]. Transaction
    /// ID in the message must be zero; this method does not check TXID.
    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)?;

        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 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.poll_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)?;
            if !header.is_compatible() {
                return std::task::Poll::Ready(Some(Err(fidl::Error::IncompatibleMagicNumber(
                    header.magic_number(),
                ))));
            }

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

                    Ok(AdministratorRequest::UnregisterSystemStorageForShutdown {
                        responder: AdministratorUnregisterSystemStorageForShutdownResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id(),
                            ordinal: header.ordinal(),
                        },
                    })
                }
                0x2607cb5dff16a5f7 => {
                    let mut req: () = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.device.manager/AdministratorSuspendWithoutExitRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = 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,
    ordinal: u64,
}

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for CoordinatorMarker {
    type Proxy = CoordinatorProxy;
    type RequestStream = CoordinatorRequestStream;
    const DEBUG_NAME: &'static str = "(anonymous) Coordinator";
}

pub trait CoordinatorProxyInterface: Send + Sync {
    type AddDeviceResponseFut: std::future::Future<Output = Result<(CoordinatorAddDeviceResult), fidl::Error>>
        + Send;
    fn r#add_device(
        &self,
        args: &mut 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: &mut CompositeDeviceDescriptor,
    ) -> Self::AddCompositeDeviceResponseFut;
    type AddCompositeNodeSpecResponseFut: std::future::Future<Output = Result<(CoordinatorAddCompositeNodeSpecResult), fidl::Error>>
        + Send;
    fn r#add_composite_node_spec(
        &self,
        name: &str,
        spec: &mut 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: &mut 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 _value: CoordinatorAddDeviceResultHandleWrapper =
            self.client.send_query::<_, _, false, false>(
                &mut (
                    args,
                    HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT::<
                        fidl::endpoints::ServerEnd<CoordinatorMarker>,
                    >(coordinator),
                    HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT::<
                        fidl::endpoints::ClientEnd<DeviceControllerMarker>,
                    >(device_controller),
                    HandleWrapperObjectTypeVMORights2147483648::<Option<fidl::Vmo>>(inspect),
                    HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT::<
                        Option<fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>>,
                    >(outgoing_dir),
                ),
                0x2790f5d086adbf8f,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_value.map(|_value| _value.0))
    }
    /// 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::<_, false>(
            &mut (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 _value: CoordinatorScheduleUnbindChildrenResultHandleWrapper =
            self.client.send_query::<_, _, false, false>(
                &mut (),
                0x658a6d68027b7139,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_value.map(|_value| _value.0))
    }
    /// 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 _value: CoordinatorBindDeviceResultHandleWrapper =
            self.client.send_query::<_, _, false, false>(
                &mut (driver_url_suffix),
                0x274db0bd334639ca,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_value.map(|_value| ()))
    }
    /// Returns the topological path of this device.
    pub fn r#get_topological_path(
        &self,
        ___deadline: zx::Time,
    ) -> Result<(CoordinatorGetTopologicalPathResult), fidl::Error> {
        let _value: CoordinatorGetTopologicalPathResultHandleWrapper =
            self.client.send_query::<_, _, false, false>(
                &mut (),
                0x319ccef1252fd6bf,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_value.map(|_value| _value.0))
    }
    /// 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 _value: CoordinatorLoadFirmwareResultHandleWrapper =
            self.client.send_query::<_, _, false, false>(
                &mut (driver_path, fw_path),
                0x5c24700e7a9815bd,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_value.map(|_value| (_value.0.into_inner(), _value.1)))
    }
    /// 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 _value: CoordinatorGetMetadataResultHandleWrapper =
            self.client.send_query::<_, _, false, false>(
                &mut (key),
                0x34abe1351145bf3f,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_value.map(|_value| _value.0))
    }
    /// 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 _value: CoordinatorGetMetadataSizeResultHandleWrapper =
            self.client.send_query::<_, _, false, false>(
                &mut (key),
                0x290826b5b7483d61,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_value.map(|_value| _value.0))
    }
    /// 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 _value: CoordinatorAddMetadataResultHandleWrapper =
            self.client.send_query::<_, _, false, false>(
                &mut (key, data),
                0x7acb84ea4eb23c94,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_value.map(|_value| ()))
    }
    /// 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: &mut CompositeDeviceDescriptor,
        ___deadline: zx::Time,
    ) -> Result<(CoordinatorAddCompositeDeviceResult), fidl::Error> {
        let _value: CoordinatorAddCompositeDeviceResultHandleWrapper =
            self.client.send_query::<_, _, false, false>(
                &mut (name, comp_desc),
                0x1610b2d89769d054,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_value.map(|_value| ()))
    }
    /// 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: &mut CompositeNodeSpecDescriptor,
        ___deadline: zx::Time,
    ) -> Result<(CoordinatorAddCompositeNodeSpecResult), fidl::Error> {
        let _value: CoordinatorAddCompositeNodeSpecResultHandleWrapper =
            self.client.send_query::<_, _, false, false>(
                &mut (name, spec),
                0x1ecc89bad1ab5c75,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_value.map(|_value| ()))
    }
    /// 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 _value: CoordinatorConnectFidlProtocolResultHandleWrapper =
            self.client.send_query::<_, _, false, false>(
                &mut (
                    fragment_name,
                    service_name,
                    protocol_name,
                    HandleWrapperObjectTypeCHANNELRights2147483648::<fidl::Channel>(server),
                ),
                0x7c9861ff4ed7fc75,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_value.map(|_value| ()))
    }
}

#[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 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 Coordinator 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: &mut 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: &mut 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: &mut 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: &mut 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 transform(
            result: Result<CoordinatorAddDeviceResultHandleWrapper, fidl::Error>,
        ) -> Result<(CoordinatorAddDeviceResult), fidl::Error> {
            result.map(|_value| _value.map(|_value| _value.0))
        }
        let send_result = self.client.call_send_raw_query::<_, false>(
            &mut (
                args,
                HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT::<
                    fidl::endpoints::ServerEnd<CoordinatorMarker>,
                >(coordinator),
                HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT::<
                    fidl::endpoints::ClientEnd<DeviceControllerMarker>,
                >(device_controller),
                HandleWrapperObjectTypeVMORights2147483648::<Option<fidl::Vmo>>(inspect),
                HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT::<
                    Option<fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>>,
                >(outgoing_dir),
            ),
            0x2790f5d086adbf8f,
            fidl::encoding::DynamicFlags::empty(),
        );
        QueryResponseFut(match send_result {
            Ok(res_fut) => future::maybe_done(
                res_fut.and_then(|buf| decode_transaction_body_fut::<_, _, false>(buf, transform)),
            ),
            Err(e) => MaybeDone::Done(Err(e)),
        })
    }
    fn r#schedule_remove(&self, mut unbind_self: bool) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (unbind_self),
            0x1bdeb4d5d1f4d21e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    type ScheduleUnbindChildrenResponseFut =
        fidl::client::QueryResponseFut<(CoordinatorScheduleUnbindChildrenResult)>;
    fn r#schedule_unbind_children(&self) -> Self::ScheduleUnbindChildrenResponseFut {
        fn transform(
            result: Result<CoordinatorScheduleUnbindChildrenResultHandleWrapper, fidl::Error>,
        ) -> Result<(CoordinatorScheduleUnbindChildrenResult), fidl::Error> {
            result.map(|_value| _value.map(|_value| _value.0))
        }
        let send_result = self.client.call_send_raw_query::<_, false>(
            &mut (),
            0x658a6d68027b7139,
            fidl::encoding::DynamicFlags::empty(),
        );
        QueryResponseFut(match send_result {
            Ok(res_fut) => future::maybe_done(
                res_fut.and_then(|buf| decode_transaction_body_fut::<_, _, false>(buf, transform)),
            ),
            Err(e) => MaybeDone::Done(Err(e)),
        })
    }
    type BindDeviceResponseFut = fidl::client::QueryResponseFut<(CoordinatorBindDeviceResult)>;
    fn r#bind_device(&self, mut driver_url_suffix: Option<&str>) -> Self::BindDeviceResponseFut {
        fn transform(
            result: Result<CoordinatorBindDeviceResultHandleWrapper, fidl::Error>,
        ) -> Result<(CoordinatorBindDeviceResult), fidl::Error> {
            result.map(|_value| _value.map(|_value| ()))
        }
        let send_result = self.client.call_send_raw_query::<_, false>(
            &mut (driver_url_suffix),
            0x274db0bd334639ca,
            fidl::encoding::DynamicFlags::empty(),
        );
        QueryResponseFut(match send_result {
            Ok(res_fut) => future::maybe_done(
                res_fut.and_then(|buf| decode_transaction_body_fut::<_, _, false>(buf, transform)),
            ),
            Err(e) => MaybeDone::Done(Err(e)),
        })
    }
    type GetTopologicalPathResponseFut =
        fidl::client::QueryResponseFut<(CoordinatorGetTopologicalPathResult)>;
    fn r#get_topological_path(&self) -> Self::GetTopologicalPathResponseFut {
        fn transform(
            result: Result<CoordinatorGetTopologicalPathResultHandleWrapper, fidl::Error>,
        ) -> Result<(CoordinatorGetTopologicalPathResult), fidl::Error> {
            result.map(|_value| _value.map(|_value| _value.0))
        }
        let send_result = self.client.call_send_raw_query::<_, false>(
            &mut (),
            0x319ccef1252fd6bf,
            fidl::encoding::DynamicFlags::empty(),
        );
        QueryResponseFut(match send_result {
            Ok(res_fut) => future::maybe_done(
                res_fut.and_then(|buf| decode_transaction_body_fut::<_, _, false>(buf, transform)),
            ),
            Err(e) => MaybeDone::Done(Err(e)),
        })
    }
    type LoadFirmwareResponseFut = fidl::client::QueryResponseFut<(CoordinatorLoadFirmwareResult)>;
    fn r#load_firmware(
        &self,
        mut driver_path: &str,
        mut fw_path: &str,
    ) -> Self::LoadFirmwareResponseFut {
        fn transform(
            result: Result<CoordinatorLoadFirmwareResultHandleWrapper, fidl::Error>,
        ) -> Result<(CoordinatorLoadFirmwareResult), fidl::Error> {
            result.map(|_value| _value.map(|_value| (_value.0.into_inner(), _value.1)))
        }
        let send_result = self.client.call_send_raw_query::<_, false>(
            &mut (driver_path, fw_path),
            0x5c24700e7a9815bd,
            fidl::encoding::DynamicFlags::empty(),
        );
        QueryResponseFut(match send_result {
            Ok(res_fut) => future::maybe_done(
                res_fut.and_then(|buf| decode_transaction_body_fut::<_, _, false>(buf, transform)),
            ),
            Err(e) => MaybeDone::Done(Err(e)),
        })
    }
    type GetMetadataResponseFut = fidl::client::QueryResponseFut<(CoordinatorGetMetadataResult)>;
    fn r#get_metadata(&self, mut key: u32) -> Self::GetMetadataResponseFut {
        fn transform(
            result: Result<CoordinatorGetMetadataResultHandleWrapper, fidl::Error>,
        ) -> Result<(CoordinatorGetMetadataResult), fidl::Error> {
            result.map(|_value| _value.map(|_value| _value.0))
        }
        let send_result = self.client.call_send_raw_query::<_, false>(
            &mut (key),
            0x34abe1351145bf3f,
            fidl::encoding::DynamicFlags::empty(),
        );
        QueryResponseFut(match send_result {
            Ok(res_fut) => future::maybe_done(
                res_fut.and_then(|buf| decode_transaction_body_fut::<_, _, false>(buf, transform)),
            ),
            Err(e) => MaybeDone::Done(Err(e)),
        })
    }
    type GetMetadataSizeResponseFut =
        fidl::client::QueryResponseFut<(CoordinatorGetMetadataSizeResult)>;
    fn r#get_metadata_size(&self, mut key: u32) -> Self::GetMetadataSizeResponseFut {
        fn transform(
            result: Result<CoordinatorGetMetadataSizeResultHandleWrapper, fidl::Error>,
        ) -> Result<(CoordinatorGetMetadataSizeResult), fidl::Error> {
            result.map(|_value| _value.map(|_value| _value.0))
        }
        let send_result = self.client.call_send_raw_query::<_, false>(
            &mut (key),
            0x290826b5b7483d61,
            fidl::encoding::DynamicFlags::empty(),
        );
        QueryResponseFut(match send_result {
            Ok(res_fut) => future::maybe_done(
                res_fut.and_then(|buf| decode_transaction_body_fut::<_, _, false>(buf, transform)),
            ),
            Err(e) => MaybeDone::Done(Err(e)),
        })
    }
    type AddMetadataResponseFut = fidl::client::QueryResponseFut<(CoordinatorAddMetadataResult)>;
    fn r#add_metadata(
        &self,
        mut key: u32,
        mut data: Option<&[u8]>,
    ) -> Self::AddMetadataResponseFut {
        fn transform(
            result: Result<CoordinatorAddMetadataResultHandleWrapper, fidl::Error>,
        ) -> Result<(CoordinatorAddMetadataResult), fidl::Error> {
            result.map(|_value| _value.map(|_value| ()))
        }
        let send_result = self.client.call_send_raw_query::<_, false>(
            &mut (key, data),
            0x7acb84ea4eb23c94,
            fidl::encoding::DynamicFlags::empty(),
        );
        QueryResponseFut(match send_result {
            Ok(res_fut) => future::maybe_done(
                res_fut.and_then(|buf| decode_transaction_body_fut::<_, _, false>(buf, transform)),
            ),
            Err(e) => MaybeDone::Done(Err(e)),
        })
    }
    type AddCompositeDeviceResponseFut =
        fidl::client::QueryResponseFut<(CoordinatorAddCompositeDeviceResult)>;
    fn r#add_composite_device(
        &self,
        mut name: &str,
        mut comp_desc: &mut CompositeDeviceDescriptor,
    ) -> Self::AddCompositeDeviceResponseFut {
        fn transform(
            result: Result<CoordinatorAddCompositeDeviceResultHandleWrapper, fidl::Error>,
        ) -> Result<(CoordinatorAddCompositeDeviceResult), fidl::Error> {
            result.map(|_value| _value.map(|_value| ()))
        }
        let send_result = self.client.call_send_raw_query::<_, false>(
            &mut (name, comp_desc),
            0x1610b2d89769d054,
            fidl::encoding::DynamicFlags::empty(),
        );
        QueryResponseFut(match send_result {
            Ok(res_fut) => future::maybe_done(
                res_fut.and_then(|buf| decode_transaction_body_fut::<_, _, false>(buf, transform)),
            ),
            Err(e) => MaybeDone::Done(Err(e)),
        })
    }
    type AddCompositeNodeSpecResponseFut =
        fidl::client::QueryResponseFut<(CoordinatorAddCompositeNodeSpecResult)>;
    fn r#add_composite_node_spec(
        &self,
        mut name: &str,
        mut spec: &mut CompositeNodeSpecDescriptor,
    ) -> Self::AddCompositeNodeSpecResponseFut {
        fn transform(
            result: Result<CoordinatorAddCompositeNodeSpecResultHandleWrapper, fidl::Error>,
        ) -> Result<(CoordinatorAddCompositeNodeSpecResult), fidl::Error> {
            result.map(|_value| _value.map(|_value| ()))
        }
        let send_result = self.client.call_send_raw_query::<_, false>(
            &mut (name, spec),
            0x1ecc89bad1ab5c75,
            fidl::encoding::DynamicFlags::empty(),
        );
        QueryResponseFut(match send_result {
            Ok(res_fut) => future::maybe_done(
                res_fut.and_then(|buf| decode_transaction_body_fut::<_, _, false>(buf, transform)),
            ),
            Err(e) => MaybeDone::Done(Err(e)),
        })
    }
    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 transform(
            result: Result<CoordinatorConnectFidlProtocolResultHandleWrapper, fidl::Error>,
        ) -> Result<(CoordinatorConnectFidlProtocolResult), fidl::Error> {
            result.map(|_value| _value.map(|_value| ()))
        }
        let send_result = self.client.call_send_raw_query::<_, false>(
            &mut (
                fragment_name,
                service_name,
                protocol_name,
                HandleWrapperObjectTypeCHANNELRights2147483648::<fidl::Channel>(server),
            ),
            0x7c9861ff4ed7fc75,
            fidl::encoding::DynamicFlags::empty(),
        );
        QueryResponseFut(match send_result {
            Ok(res_fut) => future::maybe_done(
                res_fut.and_then(|buf| decode_transaction_body_fut::<_, _, false>(buf, transform)),
            ),
            Err(e) => MaybeDone::Done(Err(e)),
        })
    }
}

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

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

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

impl CoordinatorEvent {
    /// Decodes a message buffer as a [`CoordinatorEvent`]. Transaction
    /// ID in the message must be zero; this method does not check TXID.
    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)?;

        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 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.poll_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)?;
            if !header.is_compatible() {
                return std::task::Poll::Ready(Some(Err(fidl::Error::IncompatibleMagicNumber(
                    header.magic_number(),
                ))));
            }

            std::task::Poll::Ready(Some(match header.ordinal() {
                0x2790f5d086adbf8f => {
                    let mut req: (
                        AddDeviceArgs,
                        HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT<
                            fidl::endpoints::ServerEnd<CoordinatorMarker>,
                        >,
                        HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT<
                            fidl::endpoints::ClientEnd<DeviceControllerMarker>,
                        >,
                        HandleWrapperObjectTypeVMORights2147483648<Option<fidl::Vmo>>,
                        HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT<
                            Option<fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>>,
                        >,
                    ) = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.device.manager/CoordinatorAddDeviceRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    fidl::encoding::maybe_overflowing_decode(
                        &header,
                        _body_bytes,
                        handles,
                        &mut req,
                    )?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = CoordinatorControlHandle { inner: this.inner.clone() };

                    Ok(CoordinatorRequest::AddDevice {
                        args: req.0,
                        coordinator: req.1.into_inner(),
                        device_controller: req.2.into_inner(),
                        inspect: req.3.into_inner(),
                        outgoing_dir: req.4.into_inner(),
                        responder: CoordinatorAddDeviceResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id(),
                            ordinal: header.ordinal(),
                        },
                    })
                }
                0x1bdeb4d5d1f4d21e => {
                    let mut req: (bool,) = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.device.manager/CoordinatorScheduleRemoveRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = CoordinatorControlHandle { inner: this.inner.clone() };

                    Ok(CoordinatorRequest::ScheduleRemove { unbind_self: req.0, control_handle })
                }
                0x658a6d68027b7139 => {
                    let mut req: () = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.device.manager/CoordinatorScheduleUnbindChildrenRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = CoordinatorControlHandle { inner: this.inner.clone() };

                    Ok(CoordinatorRequest::ScheduleUnbindChildren {
                        responder: CoordinatorScheduleUnbindChildrenResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id(),
                            ordinal: header.ordinal(),
                        },
                    })
                }
                0x274db0bd334639ca => {
                    let mut req: (Option<String>,) = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.device.manager/CoordinatorBindDeviceRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = CoordinatorControlHandle { inner: this.inner.clone() };

                    Ok(CoordinatorRequest::BindDevice {
                        driver_url_suffix: req.0,
                        responder: CoordinatorBindDeviceResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id(),
                            ordinal: header.ordinal(),
                        },
                    })
                }
                0x319ccef1252fd6bf => {
                    let mut req: () = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.device.manager/CoordinatorGetTopologicalPathRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = CoordinatorControlHandle { inner: this.inner.clone() };

                    Ok(CoordinatorRequest::GetTopologicalPath {
                        responder: CoordinatorGetTopologicalPathResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id(),
                            ordinal: header.ordinal(),
                        },
                    })
                }
                0x5c24700e7a9815bd => {
                    let mut req: (String, String) = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.device.manager/CoordinatorLoadFirmwareRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = CoordinatorControlHandle { inner: this.inner.clone() };

                    Ok(CoordinatorRequest::LoadFirmware {
                        driver_path: req.0,
                        fw_path: req.1,
                        responder: CoordinatorLoadFirmwareResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id(),
                            ordinal: header.ordinal(),
                        },
                    })
                }
                0x34abe1351145bf3f => {
                    let mut req: (u32,) = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.device.manager/CoordinatorGetMetadataRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = CoordinatorControlHandle { inner: this.inner.clone() };

                    Ok(CoordinatorRequest::GetMetadata {
                        key: req.0,
                        responder: CoordinatorGetMetadataResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id(),
                            ordinal: header.ordinal(),
                        },
                    })
                }
                0x290826b5b7483d61 => {
                    let mut req: (u32,) = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.device.manager/CoordinatorGetMetadataSizeRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = CoordinatorControlHandle { inner: this.inner.clone() };

                    Ok(CoordinatorRequest::GetMetadataSize {
                        key: req.0,
                        responder: CoordinatorGetMetadataSizeResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id(),
                            ordinal: header.ordinal(),
                        },
                    })
                }
                0x7acb84ea4eb23c94 => {
                    let mut req: (u32, Option<Vec<u8>>) = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.device.manager/CoordinatorAddMetadataRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = CoordinatorControlHandle { inner: this.inner.clone() };

                    Ok(CoordinatorRequest::AddMetadata {
                        key: req.0,
                        data: req.1,
                        responder: CoordinatorAddMetadataResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id(),
                            ordinal: header.ordinal(),
                        },
                    })
                }
                0x1610b2d89769d054 => {
                    let mut req: (String, CompositeDeviceDescriptor) =
                        fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.device.manager/CoordinatorAddCompositeDeviceRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    fidl::encoding::maybe_overflowing_decode(
                        &header,
                        _body_bytes,
                        handles,
                        &mut req,
                    )?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = CoordinatorControlHandle { inner: this.inner.clone() };

                    Ok(CoordinatorRequest::AddCompositeDevice {
                        name: req.0,
                        comp_desc: req.1,
                        responder: CoordinatorAddCompositeDeviceResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id(),
                            ordinal: header.ordinal(),
                        },
                    })
                }
                0x1ecc89bad1ab5c75 => {
                    let mut req: (String, CompositeNodeSpecDescriptor) =
                        fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.device.manager/CoordinatorAddCompositeNodeSpecRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    fidl::encoding::maybe_overflowing_decode(
                        &header,
                        _body_bytes,
                        handles,
                        &mut req,
                    )?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = CoordinatorControlHandle { inner: this.inner.clone() };

                    Ok(CoordinatorRequest::AddCompositeNodeSpec {
                        name: req.0,
                        spec: req.1,
                        responder: CoordinatorAddCompositeNodeSpecResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id(),
                            ordinal: header.ordinal(),
                        },
                    })
                }
                0x7c9861ff4ed7fc75 => {
                    let mut req: (
                        Option<String>,
                        Option<String>,
                        String,
                        HandleWrapperObjectTypeCHANNELRights2147483648<fidl::Channel>,
                    ) = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.device.manager/CoordinatorConnectFidlProtocolRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle = CoordinatorControlHandle { inner: this.inner.clone() };

                    Ok(CoordinatorRequest::ConnectFidlProtocol {
                        fragment_name: req.0,
                        service_name: req.1,
                        protocol_name: req.2,
                        server: req.3.into_inner(),
                        responder: CoordinatorConnectFidlProtocolResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id(),
                            ordinal: header.ordinal(),
                        },
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal(),
                    protocol_name:
                        <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,
    ordinal: u64,
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut _result: &mut CoordinatorLoadFirmwareResult) -> Result<(), fidl::Error> {
        let mut response = (match _result {
            Ok((_0, _1)) => Ok((HandleWrapperObjectTypeVMORights2147483648(_0), _1)),
            Err(e) => Err(e),
        });

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for DeviceControllerMarker {
    type Proxy = DeviceControllerProxy;
    type RequestStream = DeviceControllerRequestStream;
    const DEBUG_NAME: &'static str = "(anonymous) DeviceController";
}

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) -> 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;
}

#[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::<_, false>(
            &mut (
                HandleWrapperObjectTypeCHANNELRights2147483648::<fidl::Channel>(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::<_, false>(
            &mut (HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT::<
                fidl::endpoints::ServerEnd<fidl_fuchsia_device::ControllerMarker>,
            >(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::<_, false>(
            &mut (HandleWrapperObjectTypeCHANNELRights2147483648::<fidl::Channel>(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.
    pub fn r#bind_driver(
        &self,
        mut driver_path: &str,
        mut driver: fidl::Vmo,
        ___deadline: zx::Time,
    ) -> Result<(i32, Option<fidl::Channel>), fidl::Error> {
        let _value: (i32, HandleWrapperObjectTypeCHANNELRights2147483648<Option<fidl::Channel>>) =
            self.client.send_query::<_, _, false, false>(
                &mut (driver_path, HandleWrapperObjectTypeVMORights2147483648::<fidl::Vmo>(driver)),
                0x1600a1d1d6024855,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok((_value.0, _value.1.into_inner()))
    }
    /// 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::<_, false>(
            &mut (HandleWrapperObjectTypeCHANNELRights2147483648::<fidl::Channel>(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 _value: (i32,) = self.client.send_query::<_, _, false, false>(
            &mut (),
            0x4443bcf5eb580b37,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_value.0)
    }
    /// 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 _value: DeviceControllerUnbindResultHandleWrapper =
            self.client.send_query::<_, _, false, false>(
                &mut (),
                0x2d3f793e42cc3fd0,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_value.map(|_value| ()))
    }
    /// 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 _value: DeviceControllerCompleteRemovalResultHandleWrapper =
            self.client.send_query::<_, _, false, false>(
                &mut (),
                0x25d6d94c85d60771,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_value.map(|_value| ()))
    }
    /// 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 _value: (i32,) = self.client.send_query::<_, _, false, false>(
            &mut (flags),
            0x77bf98a1d5d4adbb,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_value.0)
    }
    /// 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 _value: (i32,) = self.client.send_query::<_, _, false, false>(
            &mut (target_system_state),
            0x4f111286b7bd9caf,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_value.0)
    }
}

#[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 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 DeviceController 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.
    pub fn r#bind_driver(
        &self,
        mut driver_path: &str,
        mut driver: fidl::Vmo,
    ) -> fidl::client::QueryResponseFut<(i32, Option<fidl::Channel>)> {
        DeviceControllerProxyInterface::r#bind_driver(self, driver_path, driver)
    }
    /// 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)
    }
}

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::<_, false>(
            &mut (
                HandleWrapperObjectTypeCHANNELRights2147483648::<fidl::Channel>(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::<_, false>(
            &mut (HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT::<
                fidl::endpoints::ServerEnd<fidl_fuchsia_device::ControllerMarker>,
            >(controller)),
            0x492ba92efb266b2a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    fn r#connect_to_device_protocol(&self, mut server: fidl::Channel) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (HandleWrapperObjectTypeCHANNELRights2147483648::<fidl::Channel>(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,
    ) -> Self::BindDriverResponseFut {
        fn transform(
            result: Result<
                (i32, HandleWrapperObjectTypeCHANNELRights2147483648<Option<fidl::Channel>>),
                fidl::Error,
            >,
        ) -> Result<(i32, Option<fidl::Channel>), fidl::Error> {
            result.map(|_value| (_value.0, _value.1.into_inner()))
        }
        let send_result = self.client.call_send_raw_query::<_, false>(
            &mut (driver_path, HandleWrapperObjectTypeVMORights2147483648::<fidl::Vmo>(driver)),
            0x1600a1d1d6024855,
            fidl::encoding::DynamicFlags::empty(),
        );
        QueryResponseFut(match send_result {
            Ok(res_fut) => future::maybe_done(
                res_fut.and_then(|buf| decode_transaction_body_fut::<_, _, false>(buf, transform)),
            ),
            Err(e) => MaybeDone::Done(Err(e)),
        })
    }
    fn r#connect_proxy_(&self, mut shadow: fidl::Channel) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (HandleWrapperObjectTypeCHANNELRights2147483648::<fidl::Channel>(shadow)),
            0x72206da90d1f3f2f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    type InitResponseFut = fidl::client::QueryResponseFut<(i32)>;
    fn r#init(&self) -> Self::InitResponseFut {
        fn transform(result: Result<(i32,), fidl::Error>) -> Result<(i32), fidl::Error> {
            result.map(|_value| _value.0)
        }
        let send_result = self.client.call_send_raw_query::<_, false>(
            &mut (),
            0x4443bcf5eb580b37,
            fidl::encoding::DynamicFlags::empty(),
        );
        QueryResponseFut(match send_result {
            Ok(res_fut) => future::maybe_done(
                res_fut.and_then(|buf| decode_transaction_body_fut::<_, _, false>(buf, transform)),
            ),
            Err(e) => MaybeDone::Done(Err(e)),
        })
    }
    type UnbindResponseFut = fidl::client::QueryResponseFut<(DeviceControllerUnbindResult)>;
    fn r#unbind(&self) -> Self::UnbindResponseFut {
        fn transform(
            result: Result<DeviceControllerUnbindResultHandleWrapper, fidl::Error>,
        ) -> Result<(DeviceControllerUnbindResult), fidl::Error> {
            result.map(|_value| _value.map(|_value| ()))
        }
        let send_result = self.client.call_send_raw_query::<_, false>(
            &mut (),
            0x2d3f793e42cc3fd0,
            fidl::encoding::DynamicFlags::empty(),
        );
        QueryResponseFut(match send_result {
            Ok(res_fut) => future::maybe_done(
                res_fut.and_then(|buf| decode_transaction_body_fut::<_, _, false>(buf, transform)),
            ),
            Err(e) => MaybeDone::Done(Err(e)),
        })
    }
    type CompleteRemovalResponseFut =
        fidl::client::QueryResponseFut<(DeviceControllerCompleteRemovalResult)>;
    fn r#complete_removal(&self) -> Self::CompleteRemovalResponseFut {
        fn transform(
            result: Result<DeviceControllerCompleteRemovalResultHandleWrapper, fidl::Error>,
        ) -> Result<(DeviceControllerCompleteRemovalResult), fidl::Error> {
            result.map(|_value| _value.map(|_value| ()))
        }
        let send_result = self.client.call_send_raw_query::<_, false>(
            &mut (),
            0x25d6d94c85d60771,
            fidl::encoding::DynamicFlags::empty(),
        );
        QueryResponseFut(match send_result {
            Ok(res_fut) => future::maybe_done(
                res_fut.and_then(|buf| decode_transaction_body_fut::<_, _, false>(buf, transform)),
            ),
            Err(e) => MaybeDone::Done(Err(e)),
        })
    }
    type SuspendResponseFut = fidl::client::QueryResponseFut<(i32)>;
    fn r#suspend(&self, mut flags: u32) -> Self::SuspendResponseFut {
        fn transform(result: Result<(i32,), fidl::Error>) -> Result<(i32), fidl::Error> {
            result.map(|_value| _value.0)
        }
        let send_result = self.client.call_send_raw_query::<_, false>(
            &mut (flags),
            0x77bf98a1d5d4adbb,
            fidl::encoding::DynamicFlags::empty(),
        );
        QueryResponseFut(match send_result {
            Ok(res_fut) => future::maybe_done(
                res_fut.and_then(|buf| decode_transaction_body_fut::<_, _, false>(buf, transform)),
            ),
            Err(e) => MaybeDone::Done(Err(e)),
        })
    }
    type ResumeResponseFut = fidl::client::QueryResponseFut<(i32)>;
    fn r#resume(&self, mut target_system_state: u32) -> Self::ResumeResponseFut {
        fn transform(result: Result<(i32,), fidl::Error>) -> Result<(i32), fidl::Error> {
            result.map(|_value| _value.0)
        }
        let send_result = self.client.call_send_raw_query::<_, false>(
            &mut (target_system_state),
            0x4f111286b7bd9caf,
            fidl::encoding::DynamicFlags::empty(),
        );
        QueryResponseFut(match send_result {
            Ok(res_fut) => future::maybe_done(
                res_fut.and_then(|buf| decode_transaction_body_fut::<_, _, false>(buf, transform)),
            ),
            Err(e) => MaybeDone::Done(Err(e)),
        })
    }
}

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

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

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

impl DeviceControllerEvent {
    /// Decodes a message buffer as a [`DeviceControllerEvent`]. Transaction
    /// ID in the message must be zero; this method does not check TXID.
    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)?;

        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 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.poll_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)?;
            if !header.is_compatible() {
                return std::task::Poll::Ready(Some(Err(fidl::Error::IncompatibleMagicNumber(
                    header.magic_number(),
                ))));
            }

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

                    Ok(DeviceControllerRequest::ConnectMultiplexed {
                        server: req.0.into_inner(),
                        include_node: req.1,
                        include_controller: req.2,
                        control_handle,
                    })
                }
                0x492ba92efb266b2a => {
                    let mut req: (
                        HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT<
                            fidl::endpoints::ServerEnd<fidl_fuchsia_device::ControllerMarker>,
                        >,
                    ) = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.device.manager/DeviceControllerConnectToControllerRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle =
                        DeviceControllerControlHandle { inner: this.inner.clone() };

                    Ok(DeviceControllerRequest::ConnectToController {
                        controller: req.0.into_inner(),
                        control_handle,
                    })
                }
                0x65c280a3b9cb9300 => {
                    let mut req: (HandleWrapperObjectTypeCHANNELRights2147483648<fidl::Channel>,) =
                        fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.device.manager/DeviceControllerConnectToDeviceProtocolRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle =
                        DeviceControllerControlHandle { inner: this.inner.clone() };

                    Ok(DeviceControllerRequest::ConnectToDeviceProtocol {
                        server: req.0.into_inner(),
                        control_handle,
                    })
                }
                0x1600a1d1d6024855 => {
                    let mut req: (String, HandleWrapperObjectTypeVMORights2147483648<fidl::Vmo>) =
                        fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.device.manager/DeviceControllerBindDriverRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle =
                        DeviceControllerControlHandle { inner: this.inner.clone() };

                    Ok(DeviceControllerRequest::BindDriver {
                        driver_path: req.0,
                        driver: req.1.into_inner(),
                        responder: DeviceControllerBindDriverResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id(),
                            ordinal: header.ordinal(),
                        },
                    })
                }
                0x72206da90d1f3f2f => {
                    let mut req: (HandleWrapperObjectTypeCHANNELRights2147483648<fidl::Channel>,) =
                        fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.device.manager/DeviceControllerConnectProxy_Request");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle =
                        DeviceControllerControlHandle { inner: this.inner.clone() };

                    Ok(DeviceControllerRequest::ConnectProxy_ {
                        shadow: req.0.into_inner(),
                        control_handle,
                    })
                }
                0x4443bcf5eb580b37 => {
                    let mut req: () = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.device.manager/DeviceControllerInitRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle =
                        DeviceControllerControlHandle { inner: this.inner.clone() };

                    Ok(DeviceControllerRequest::Init {
                        responder: DeviceControllerInitResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id(),
                            ordinal: header.ordinal(),
                        },
                    })
                }
                0x2d3f793e42cc3fd0 => {
                    let mut req: () = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.device.manager/DeviceControllerUnbindRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle =
                        DeviceControllerControlHandle { inner: this.inner.clone() };

                    Ok(DeviceControllerRequest::Unbind {
                        responder: DeviceControllerUnbindResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id(),
                            ordinal: header.ordinal(),
                        },
                    })
                }
                0x25d6d94c85d60771 => {
                    let mut req: () = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.device.manager/DeviceControllerCompleteRemovalRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle =
                        DeviceControllerControlHandle { inner: this.inner.clone() };

                    Ok(DeviceControllerRequest::CompleteRemoval {
                        responder: DeviceControllerCompleteRemovalResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id(),
                            ordinal: header.ordinal(),
                        },
                    })
                }
                0x77bf98a1d5d4adbb => {
                    let mut req: (u32,) = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.device.manager/DeviceControllerSuspendRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle =
                        DeviceControllerControlHandle { inner: this.inner.clone() };

                    Ok(DeviceControllerRequest::Suspend {
                        flags: req.0,
                        responder: DeviceControllerSuspendResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id(),
                            ordinal: header.ordinal(),
                        },
                    })
                }
                0x4f111286b7bd9caf => {
                    let mut req: (u32,) = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.device.manager/DeviceControllerResumeRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle =
                        DeviceControllerControlHandle { inner: this.inner.clone() };

                    Ok(DeviceControllerRequest::Resume {
                        target_system_state: req.0,
                        responder: DeviceControllerResumeResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id(),
                            ordinal: header.ordinal(),
                        },
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal(),
                    protocol_name:
                        <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.
    BindDriver {
        driver_path: String,

        driver: fidl::Vmo,
        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 },
}

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, DeviceControllerBindDriverResponder)> {
        if let DeviceControllerRequest::BindDriver { driver_path, driver, responder } = self {
            Some((driver_path, driver, 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
        }
    }

    /// 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",
        }
    }
}

#[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,
    ordinal: u64,
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for DeviceWatcherMarker {
    type Proxy = DeviceWatcherProxy;
    type RequestStream = DeviceWatcherRequestStream;
    const DEBUG_NAME: &'static str = "(anonymous) DeviceWatcher";
}

pub trait DeviceWatcherProxyInterface: Send + Sync {
    type NextDeviceResponseFut: std::future::Future<Output = Result<(DeviceWatcherNextDeviceResult), fidl::Error>>
        + Send;
    fn r#next_device(&self) -> Self::NextDeviceResponseFut;
}

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

#[cfg(target_os = "fuchsia")]
impl DeviceWatcherSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <DeviceWatcherMarker 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<DeviceWatcherEvent, fidl::Error> {
        DeviceWatcherEvent::decode(self.client.wait_for_event(deadline)?)
    }
    /// A Hanging-Get API that returns the next device. This will not return until
    /// there is a new device available. Call this repeatedly to get all devices.
    /// If there is already an outstanding request then calling this again will return
    /// ZX_ERR_ALREADY_BOUND.
    pub fn r#next_device(
        &self,
        ___deadline: zx::Time,
    ) -> Result<(DeviceWatcherNextDeviceResult), fidl::Error> {
        let _value: DeviceWatcherNextDeviceResultHandleWrapper =
            self.client.send_query::<_, _, false, false>(
                &mut (),
                0x1b28b479ec622ed3,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_value.map(|_value| _value.0.into_inner()))
    }
}

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

impl fidl::endpoints::Proxy for DeviceWatcherProxy {
    type Protocol = DeviceWatcherMarker;

    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 DeviceWatcherProxy {
    /// Create a new Proxy for DeviceWatcher
    pub fn new(channel: fidl::AsyncChannel) -> Self {
        let protocol_name = <DeviceWatcherMarker 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 DeviceWatcher protocol
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> DeviceWatcherEventStream {
        DeviceWatcherEventStream { event_receiver: self.client.take_event_receiver() }
    }
    /// A Hanging-Get API that returns the next device. This will not return until
    /// there is a new device available. Call this repeatedly to get all devices.
    /// If there is already an outstanding request then calling this again will return
    /// ZX_ERR_ALREADY_BOUND.
    pub fn r#next_device(&self) -> fidl::client::QueryResponseFut<(DeviceWatcherNextDeviceResult)> {
        DeviceWatcherProxyInterface::r#next_device(self)
    }
}

impl DeviceWatcherProxyInterface for DeviceWatcherProxy {
    type NextDeviceResponseFut = fidl::client::QueryResponseFut<(DeviceWatcherNextDeviceResult)>;
    fn r#next_device(&self) -> Self::NextDeviceResponseFut {
        fn transform(
            result: Result<DeviceWatcherNextDeviceResultHandleWrapper, fidl::Error>,
        ) -> Result<(DeviceWatcherNextDeviceResult), fidl::Error> {
            result.map(|_value| _value.map(|_value| _value.0.into_inner()))
        }
        let send_result = self.client.call_send_raw_query::<_, false>(
            &mut (),
            0x1b28b479ec622ed3,
            fidl::encoding::DynamicFlags::empty(),
        );
        QueryResponseFut(match send_result {
            Ok(res_fut) => future::maybe_done(
                res_fut.and_then(|buf| decode_transaction_body_fut::<_, _, false>(buf, transform)),
            ),
            Err(e) => MaybeDone::Done(Err(e)),
        })
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for DeviceWatcherRequestStream {
    type Protocol = DeviceWatcherMarker;
    type ControlHandle = DeviceWatcherControlHandle;

    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 {
        DeviceWatcherControlHandle { 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 DeviceWatcherRequestStream {
    type Item = Result<DeviceWatcherRequest, fidl::Error>;

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

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

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

                    Ok(DeviceWatcherRequest::NextDevice {
                        responder: DeviceWatcherNextDeviceResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id(),
                            ordinal: header.ordinal(),
                        },
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal(),
                    protocol_name:
                        <DeviceWatcherMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
        })
    }
}
/// This protocol represents watching a specific class of devices. Each client
/// that connects will be able to poll `NextDevice` to be able to get all devices.
#[derive(Debug)]
pub enum DeviceWatcherRequest {
    /// A Hanging-Get API that returns the next device. This will not return until
    /// there is a new device available. Call this repeatedly to get all devices.
    /// If there is already an outstanding request then calling this again will return
    /// ZX_ERR_ALREADY_BOUND.
    NextDevice { responder: DeviceWatcherNextDeviceResponder },
}

impl DeviceWatcherRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_next_device(self) -> Option<(DeviceWatcherNextDeviceResponder)> {
        if let DeviceWatcherRequest::NextDevice { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

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

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

impl fidl::endpoints::ControlHandle for DeviceWatcherControlHandle {
    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 DeviceWatcherControlHandle {}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DeviceWatcherNextDeviceResponder {
    control_handle: std::mem::ManuallyDrop<DeviceWatcherControlHandle>,
    tx_id: u32,
    ordinal: u64,
}

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

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

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

    fn send_raw(&self, mut _result: &mut DeviceWatcherNextDeviceResult) -> Result<(), fidl::Error> {
        let mut response = (match _result {
            Ok((_0)) => Ok((HandleWrapperObjectTypeCHANNELRights2147483648(_0))),
            Err(e) => Err(e),
        });

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

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

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

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct 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_: &mut DeviceType,
        local_device_id: u64,
    ) -> Self::CreateDeviceResponseFut;
    fn r#start(
        &self,
        start_args: fidl_fuchsia_driver_framework::DriverStartArgs,
        driver: fidl::endpoints::ServerEnd<fidl_fuchsia_driver_host::DriverMarker>,
    ) -> Result<(), fidl::Error>;
    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_: &mut DeviceType,
        mut local_device_id: u64,
        ___deadline: zx::Time,
    ) -> Result<(i32), fidl::Error> {
        let _value: (i32,) = self.client.send_query::<_, _, false, false>(
            &mut (
                HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT::<
                    fidl::endpoints::ClientEnd<CoordinatorMarker>,
                >(coordinator),
                HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT::<
                    fidl::endpoints::ServerEnd<DeviceControllerMarker>,
                >(device_controller),
                type_,
                local_device_id,
            ),
            0x5d136e167043e7de,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_value.0)
    }
    /// Start a DFv2 driver within a driver host.
    pub fn r#start(
        &self,
        mut start_args: fidl_fuchsia_driver_framework::DriverStartArgs,
        mut driver: fidl::endpoints::ServerEnd<fidl_fuchsia_driver_host::DriverMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (
                start_args,
                HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT::<
                    fidl::endpoints::ServerEnd<fidl_fuchsia_driver_host::DriverMarker>,
                >(driver),
            ),
            0x4322cd91f51415b3,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    /// 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 _value: (i32,) = self.client.send_query::<_, _, false, false>(
            &mut (),
            0x1a870ec87b9fa33d,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_value.0)
    }
}

#[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 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 DriverHostController 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_: &mut DeviceType,
        mut local_device_id: u64,
    ) -> fidl::client::QueryResponseFut<(i32)> {
        DriverHostControllerProxyInterface::r#create_device(
            self,
            coordinator,
            device_controller,
            type_,
            local_device_id,
        )
    }
    /// Start a DFv2 driver within a driver host.
    pub fn r#start(
        &self,
        mut start_args: fidl_fuchsia_driver_framework::DriverStartArgs,
        mut driver: fidl::endpoints::ServerEnd<fidl_fuchsia_driver_host::DriverMarker>,
    ) -> Result<(), fidl::Error> {
        DriverHostControllerProxyInterface::r#start(self, start_args, driver)
    }
    /// 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_: &mut DeviceType,
        mut local_device_id: u64,
    ) -> Self::CreateDeviceResponseFut {
        fn transform(result: Result<(i32,), fidl::Error>) -> Result<(i32), fidl::Error> {
            result.map(|_value| _value.0)
        }
        let send_result = self.client.call_send_raw_query::<_, false>(
            &mut (
                HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT::<
                    fidl::endpoints::ClientEnd<CoordinatorMarker>,
                >(coordinator),
                HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT::<
                    fidl::endpoints::ServerEnd<DeviceControllerMarker>,
                >(device_controller),
                type_,
                local_device_id,
            ),
            0x5d136e167043e7de,
            fidl::encoding::DynamicFlags::empty(),
        );
        QueryResponseFut(match send_result {
            Ok(res_fut) => future::maybe_done(
                res_fut.and_then(|buf| decode_transaction_body_fut::<_, _, false>(buf, transform)),
            ),
            Err(e) => MaybeDone::Done(Err(e)),
        })
    }
    fn r#start(
        &self,
        mut start_args: fidl_fuchsia_driver_framework::DriverStartArgs,
        mut driver: fidl::endpoints::ServerEnd<fidl_fuchsia_driver_host::DriverMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<_, false>(
            &mut (
                start_args,
                HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT::<
                    fidl::endpoints::ServerEnd<fidl_fuchsia_driver_host::DriverMarker>,
                >(driver),
            ),
            0x4322cd91f51415b3,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    type RestartResponseFut = fidl::client::QueryResponseFut<(i32)>;
    fn r#restart(&self) -> Self::RestartResponseFut {
        fn transform(result: Result<(i32,), fidl::Error>) -> Result<(i32), fidl::Error> {
            result.map(|_value| _value.0)
        }
        let send_result = self.client.call_send_raw_query::<_, false>(
            &mut (),
            0x1a870ec87b9fa33d,
            fidl::encoding::DynamicFlags::empty(),
        );
        QueryResponseFut(match send_result {
            Ok(res_fut) => future::maybe_done(
                res_fut.and_then(|buf| decode_transaction_body_fut::<_, _, false>(buf, transform)),
            ),
            Err(e) => MaybeDone::Done(Err(e)),
        })
    }
}

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

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

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

impl DriverHostControllerEvent {
    /// Decodes a message buffer as a [`DriverHostControllerEvent`]. Transaction
    /// ID in the message must be zero; this method does not check TXID.
    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)?;

        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 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.poll_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)?;
            if !header.is_compatible() {
                return std::task::Poll::Ready(Some(Err(fidl::Error::IncompatibleMagicNumber(
                    header.magic_number(),
                ))));
            }

            std::task::Poll::Ready(Some(match header.ordinal() {
                0x5d136e167043e7de => {
                    let mut req: (
                        HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT<
                            fidl::endpoints::ClientEnd<CoordinatorMarker>,
                        >,
                        HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT<
                            fidl::endpoints::ServerEnd<DeviceControllerMarker>,
                        >,
                        DeviceType,
                        u64,
                    ) = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.device.manager/DriverHostControllerCreateDeviceRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle =
                        DriverHostControllerControlHandle { inner: this.inner.clone() };

                    Ok(DriverHostControllerRequest::CreateDevice {
                        coordinator: req.0.into_inner(),
                        device_controller: req.1.into_inner(),
                        type_: req.2,
                        local_device_id: req.3,
                        responder: DriverHostControllerCreateDeviceResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id(),
                            ordinal: header.ordinal(),
                        },
                    })
                }
                0x4322cd91f51415b3 => {
                    let mut req: (
                        fidl_fuchsia_driver_framework::DriverStartArgs,
                        HandleWrapperObjectTypeCHANNELRightsCHANNEL_DEFAULT<
                            fidl::endpoints::ServerEnd<fidl_fuchsia_driver_host::DriverMarker>,
                        >,
                    ) = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.device.manager/DriverHostControllerStartRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    fidl::encoding::maybe_overflowing_decode(
                        &header,
                        _body_bytes,
                        handles,
                        &mut req,
                    )?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle =
                        DriverHostControllerControlHandle { inner: this.inner.clone() };

                    Ok(DriverHostControllerRequest::Start {
                        start_args: req.0,
                        driver: req.1.into_inner(),
                        control_handle,
                    })
                }
                0x1a870ec87b9fa33d => {
                    let mut req: () = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.device.manager/DriverHostControllerRestartRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle =
                        DriverHostControllerControlHandle { inner: this.inner.clone() };

                    Ok(DriverHostControllerRequest::Restart {
                        responder: DriverHostControllerRestartResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id(),
                            ordinal: header.ordinal(),
                        },
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal(),
                    protocol_name:
                        <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,
    },
    /// Start a DFv2 driver within a driver host.
    Start {
        start_args: fidl_fuchsia_driver_framework::DriverStartArgs,

        driver: fidl::endpoints::ServerEnd<fidl_fuchsia_driver_host::DriverMarker>,
        control_handle: DriverHostControllerControlHandle,
    },
    /// 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_start(
        self,
    ) -> Option<(
        fidl_fuchsia_driver_framework::DriverStartArgs,
        fidl::endpoints::ServerEnd<fidl_fuchsia_driver_host::DriverMarker>,
        DriverHostControllerControlHandle,
    )> {
        if let DriverHostControllerRequest::Start { start_args, driver, control_handle } = self {
            Some((start_args, driver, control_handle))
        } 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::Start { .. } => "start",
            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,
    ordinal: u64,
}

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

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

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

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

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

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

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

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

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

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

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

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

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct 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 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 _value: (SystemPowerState,) = self.client.send_query::<_, _, false, false>(
            &mut (),
            0x12161ad87afc0b63,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_value.0)
    }
    /// 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 _value: SystemStateTransitionGetMexecZbisResultHandleWrapper =
            self.client.send_query::<_, _, false, false>(
                &mut (),
                0x1ca6dd89b84f94c7,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_value.map(|_value| (_value.0.into_inner(), _value.1.into_inner())))
    }
}

#[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 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 SystemStateTransition 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 transform(
            result: Result<(SystemPowerState,), fidl::Error>,
        ) -> Result<(SystemPowerState), fidl::Error> {
            result.map(|_value| _value.0)
        }
        let send_result = self.client.call_send_raw_query::<_, false>(
            &mut (),
            0x12161ad87afc0b63,
            fidl::encoding::DynamicFlags::empty(),
        );
        QueryResponseFut(match send_result {
            Ok(res_fut) => future::maybe_done(
                res_fut.and_then(|buf| decode_transaction_body_fut::<_, _, false>(buf, transform)),
            ),
            Err(e) => MaybeDone::Done(Err(e)),
        })
    }
    type GetMexecZbisResponseFut =
        fidl::client::QueryResponseFut<(SystemStateTransitionGetMexecZbisResult)>;
    fn r#get_mexec_zbis(&self) -> Self::GetMexecZbisResponseFut {
        fn transform(
            result: Result<SystemStateTransitionGetMexecZbisResultHandleWrapper, fidl::Error>,
        ) -> Result<(SystemStateTransitionGetMexecZbisResult), fidl::Error> {
            result.map(|_value| _value.map(|_value| (_value.0.into_inner(), _value.1.into_inner())))
        }
        let send_result = self.client.call_send_raw_query::<_, false>(
            &mut (),
            0x1ca6dd89b84f94c7,
            fidl::encoding::DynamicFlags::empty(),
        );
        QueryResponseFut(match send_result {
            Ok(res_fut) => future::maybe_done(
                res_fut.and_then(|buf| decode_transaction_body_fut::<_, _, false>(buf, transform)),
            ),
            Err(e) => MaybeDone::Done(Err(e)),
        })
    }
}

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

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

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

impl SystemStateTransitionEvent {
    /// Decodes a message buffer as a [`SystemStateTransitionEvent`]. Transaction
    /// ID in the message must be zero; this method does not check TXID.
    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)?;

        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 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.poll_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)?;
            if !header.is_compatible() {
                return std::task::Poll::Ready(Some(Err(fidl::Error::IncompatibleMagicNumber(
                    header.magic_number(),
                ))));
            }

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

                    Ok(SystemStateTransitionRequest::GetTerminationSystemState {
                        responder: SystemStateTransitionGetTerminationSystemStateResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id(),
                            ordinal: header.ordinal(),
                        },
                    })
                }
                0x1ca6dd89b84f94c7 => {
                    let mut req: () = fidl::encoding::Decodable::new_empty();
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.device.manager/SystemStateTransitionGetMexecZbisRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::BYTE_OVERFLOW)
                    {
                        Err(fidl::Error::LargeMessageImpossible)?;
                    }
                    fidl::encoding::Decoder::decode_into(&header, _body_bytes, handles, &mut req)?;
                    fidl::duration_end!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "size" => bytes.len() as u32, "handle_count" => handles.len() as u32);
                    let control_handle =
                        SystemStateTransitionControlHandle { inner: this.inner.clone() };

                    Ok(SystemStateTransitionRequest::GetMexecZbis {
                        responder: SystemStateTransitionGetMexecZbisResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id(),
                            ordinal: header.ordinal(),
                        },
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal(),
                    protocol_name:
                        <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,
    ordinal: u64,
}

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

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

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

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

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

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

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

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

    fn send_raw(
        &self,
        mut _result: &mut SystemStateTransitionGetMexecZbisResult,
    ) -> Result<(), fidl::Error> {
        let mut response = (match _result {
            Ok((_0, _1)) => Ok((
                HandleWrapperObjectTypeVMORights2147483648(_0),
                HandleWrapperObjectTypeVMORights2147483648(_1),
            )),
            Err(e) => Err(e),
        });

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

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

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