// 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::QueryResponseFut,
        encoding::zerocopy,
        endpoints::{ControlHandle as _, Responder as _},
        fidl_bits, fidl_enum, fidl_struct, fidl_table, fidl_union,
    },
    fuchsia_zircon_status as zx_status,
    futures::future::{self, MaybeDone, TryFutureExt},
};

const _FIDL_TRACE_BINDINGS_RUST: u32 = 6;
bitflags! {
    pub struct DeviceFlags: u32 {
        const IMMORTAL = 1;
        /// This device requires that children are created in a
        /// new driver_host attached to a proxy device
        const MUST_ISOLATE = 2;
        /// This device is bound and not eligible for binding
        /// again until unbound.  Not allowed on ALLOW_MULTI_COMPOSITE ctx.
        const BOUND = 8;
        /// Device has been remove()'d
        const DEAD = 16;
        /// This device is a fragment of a composite device and
        /// can be part of multiple composite devices.
        const ALLOW_MULTI_COMPOSITE = 32;
        /// Device is a proxy -- its "parent" is the device it's
        /// a proxy to.
        const PROXY = 64;
        /// Device is not visible in devfs or bindable.
        /// Devices may be created in this state, but may not
        /// return to this state once made visible.
        const INVISIBLE = 128;
        /// Device should not go through auto-bind process.
        const SKIP_AUTOBIND = 256;
    }
}

impl DeviceFlags {
    #[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: DeviceFlags,
    prim_ty: u32,
    strict: true,
}

pub const BINDING_RESULT_MAX: u8 = 10;

#[derive(Debug, Clone, PartialEq)]
pub enum BindRulesBytecode {
    /// Bind rules in the old bytecode format.
    BytecodeV1(Vec<fidl_fuchsia_device_manager::BindInstruction>),
    /// Bind rules in the new bytecode format.
    BytecodeV2(Vec<u8>),
}

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

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

fidl_union! {
    name: BindRulesBytecode,
    members: [
        BytecodeV1 {
            ty: fidl::encoding::UnboundedVector<fidl_fuchsia_device_manager::BindInstruction>,
            ordinal: 1,
        },
        BytecodeV2 {
            ty: fidl::encoding::UnboundedVector<u8>,
            ordinal: 2,
        },
    ],
}

/// Contains information for the composite node.
#[derive(Debug, Clone, PartialEq)]
pub enum CompositeNodeInfo {
    Legacy(LegacyCompositeNodeInfo),
    Parents(Vec<CompositeParentNodeInfo>),
}

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

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

fidl_union! {
    name: CompositeNodeInfo,
    members: [
        Legacy {
            ty: LegacyCompositeNodeInfo,
            ordinal: 1,
        },
        Parents {
            ty: fidl::encoding::UnboundedVector<CompositeParentNodeInfo>,
            ordinal: 2,
        },
    ],
}

#[derive(Debug, Clone, PartialEq)]
pub struct CompositeInfoIteratorGetNextResponse {
    pub composites: Vec<CompositeInfo>,
}

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

fidl_struct! {
    name: CompositeInfoIteratorGetNextResponse,
    members: [
        composites {
            ty: fidl::encoding::UnboundedVector<CompositeInfo>,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 16,
    size_v2: 16,
    align_v1: 8,
    align_v2: 8,
}

#[derive(Debug, Clone, PartialEq)]
pub struct CompositeNodeSpecIteratorGetNextResponse {
    pub specs: Vec<CompositeNodeSpecInfo>,
}

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

fidl_struct! {
    name: CompositeNodeSpecIteratorGetNextResponse,
    members: [
        specs {
            ty: fidl::encoding::UnboundedVector<CompositeNodeSpecInfo>,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 16,
    size_v2: 16,
    align_v1: 8,
    align_v2: 8,
}

#[derive(Debug, Clone, PartialEq)]
pub struct DeviceInfoIteratorGetNextResponse {
    pub drivers: Vec<DeviceInfo>,
}

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

fidl_struct! {
    name: DeviceInfoIteratorGetNextResponse,
    members: [
        drivers {
            ty: fidl::encoding::UnboundedVector<DeviceInfo>,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 16,
    size_v2: 16,
    align_v1: 8,
    align_v2: 8,
}

#[derive(Debug, Clone, PartialEq)]
pub struct DriverDevelopmentAddTestNodeRequest {
    pub args: TestNodeAddArgs,
}

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

fidl_struct! {
    name: DriverDevelopmentAddTestNodeRequest,
    members: [
        args {
            ty: TestNodeAddArgs,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 16,
    size_v2: 16,
    align_v1: 8,
    align_v2: 8,
}

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct DriverDevelopmentGetCompositeInfoRequest {
    pub iterator: fidl::endpoints::ServerEnd<CompositeInfoIteratorMarker>,
}

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

fidl_struct! {
    name: DriverDevelopmentGetCompositeInfoRequest,
    resource: true,
    members: [
        iterator {
            ty: fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<CompositeInfoIteratorMarker>>,
            resource: true,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 4,
    size_v2: 4,
    align_v1: 4,
    align_v2: 4,
}

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct DriverDevelopmentGetDeviceInfoRequest {
    pub device_filter: Vec<String>,
    pub iterator: fidl::endpoints::ServerEnd<DeviceInfoIteratorMarker>,
    pub exact_match: bool,
}

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

fidl_struct! {
    name: DriverDevelopmentGetDeviceInfoRequest,
    resource: true,
    members: [
        device_filter {
            ty: fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        iterator {
            ty: fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<DeviceInfoIteratorMarker>>,
            resource: true,
            index: 1,
            typevar: T1,
            offset_v1: 16,
            offset_v2: 16,
        },
        exact_match {
            ty: bool,
            index: 2,
            typevar: T2,
            offset_v1: 20,
            offset_v2: 20,
        },
    ],
    padding_v1: [
        {
            ty: u64,
            offset: 16,
            mask: 0xffffff0000000000u64,
        },
    ],
    padding_v2: [
        {
            ty: u64,
            offset: 16,
            mask: 0xffffff0000000000u64,
        },
    ],
    size_v1: 24,
    size_v2: 24,
    align_v1: 8,
    align_v2: 8,
}

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

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

fidl_struct! {
    name: DriverDevelopmentIsDfv2Response,
    members: [
        response {
            ty: bool,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 1,
    size_v2: 1,
    align_v1: 1,
    align_v2: 1,
}

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

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

fidl_struct! {
    name: DriverDevelopmentRemoveTestNodeRequest,
    members: [
        name {
            ty: fidl::encoding::UnboundedString,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 16,
    size_v2: 16,
    align_v1: 8,
    align_v2: 8,
}

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

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

fidl_struct! {
    name: DriverDevelopmentRestartDriverHostsRequest,
    members: [
        driver_path {
            ty: fidl::encoding::UnboundedString,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 16,
    size_v2: 16,
    align_v1: 8,
    align_v2: 8,
}

#[derive(Debug, Clone, PartialEq)]
pub struct DriverDevelopmentBindAllUnboundNodesResponse {
    /// List of new bindings that happened as a result of this.
    pub binding_result: Vec<NodeBindingInfo>,
}

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

fidl_struct! {
    name: DriverDevelopmentBindAllUnboundNodesResponse,
    members: [
        binding_result {
            ty: fidl::encoding::UnboundedVector<NodeBindingInfo>,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 16,
    size_v2: 16,
    align_v1: 8,
    align_v2: 8,
}

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

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

fidl_struct! {
    copy: true,
    name: DriverDevelopmentRestartDriverHostsResponse,
    members: [
        count {
            ty: u32,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 4,
    size_v2: 4,
    align_v1: 4,
    align_v2: 4,
}

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct DriverIndexGetCompositeNodeSpecsRequest {
    pub name_filter: Option<String>,
    pub iterator: fidl::endpoints::ServerEnd<CompositeNodeSpecIteratorMarker>,
}

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

fidl_struct! {
    name: DriverIndexGetCompositeNodeSpecsRequest,
    resource: true,
    members: [
        name_filter {
            ty: fidl::encoding::Optional<fidl::encoding::UnboundedString>,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        iterator {
            ty: fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<CompositeNodeSpecIteratorMarker>>,
            resource: true,
            index: 1,
            typevar: T1,
            offset_v1: 16,
            offset_v2: 16,
        },
    ],
    padding_v1: [
        {
            ty: u64,
            offset: 16,
            mask: 0xffffffff00000000u64,
        },
    ],
    padding_v2: [
        {
            ty: u64,
            offset: 16,
            mask: 0xffffffff00000000u64,
        },
    ],
    size_v1: 24,
    size_v2: 24,
    align_v1: 8,
    align_v2: 8,
}

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct DriverIndexGetDriverInfoRequest {
    pub driver_filter: Vec<String>,
    pub iterator: fidl::endpoints::ServerEnd<DriverInfoIteratorMarker>,
}

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

fidl_struct! {
    name: DriverIndexGetDriverInfoRequest,
    resource: true,
    members: [
        driver_filter {
            ty: fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
        iterator {
            ty: fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<DriverInfoIteratorMarker>>,
            resource: true,
            index: 1,
            typevar: T1,
            offset_v1: 16,
            offset_v2: 16,
        },
    ],
    padding_v1: [
        {
            ty: u64,
            offset: 16,
            mask: 0xffffffff00000000u64,
        },
    ],
    padding_v2: [
        {
            ty: u64,
            offset: 16,
            mask: 0xffffffff00000000u64,
        },
    ],
    size_v1: 24,
    size_v2: 24,
    align_v1: 8,
    align_v2: 8,
}

#[derive(Debug, Clone, PartialEq)]
pub struct DriverInfoIteratorGetNextResponse {
    pub drivers: Vec<DriverInfo>,
}

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

fidl_struct! {
    name: DriverInfoIteratorGetNextResponse,
    members: [
        drivers {
            ty: fidl::encoding::UnboundedVector<DriverInfo>,
            index: 0,
            typevar: T0,
            offset_v1: 0,
            offset_v2: 0,
        },
    ],
    padding_v1: [
    ],
    padding_v2: [
    ],
    size_v1: 16,
    size_v2: 16,
    align_v1: 8,
    align_v2: 8,
}

/// Information for a composite node.
#[derive(Debug, Clone, PartialEq)]
pub struct CompositeInfo {
    /// The name of the composite node.
    pub name: Option<String>,
    /// The url of the driver matched to the composite node.
    pub driver: Option<String>,
    /// The topological of the composite node. Empty if a composite node wasn't created.
    pub topological_path: Option<String>,
    /// The primary node index.
    pub primary_index: Option<u32>,
    /// Information on the composite node.
    pub node_info: Option<CompositeNodeInfo>,
    #[deprecated = "Use `..CompositeInfo::EMPTY` to construct and `..` to match."]
    #[doc(hidden)]
    pub __non_exhaustive: (),
}

impl CompositeInfo {
    /// An empty table with every field set to `None`.
    #[allow(deprecated)]
    pub const EMPTY: Self = Self {
        name: None,
        driver: None,
        topological_path: None,
        primary_index: None,
        node_info: None,
        __non_exhaustive: (),
    };
}

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

fidl_table! {
    name: CompositeInfo,
    members: [
        name {
            ty: fidl::encoding::UnboundedString,
            ordinal: 1,
        },
        driver {
            ty: fidl::encoding::UnboundedString,
            ordinal: 2,
        },
        topological_path {
            ty: fidl::encoding::UnboundedString,
            ordinal: 3,
        },
        primary_index {
            ty: u32,
            ordinal: 4,
        },
        node_info {
            ty: CompositeNodeInfo,
            ordinal: 5,
        },
    ],
}

#[derive(Debug, Clone, PartialEq)]
pub struct CompositeNodeSpecInfo {
    /// The name of the node group.
    pub name: Option<String>,
    /// The url of the driver matched to the spec. Empty if no driver has matched
    /// to this node group.
    pub driver: Option<String>,
    /// The primary node index, this comes from the matched driver. Empty if no driver has matched
    /// to this node group.
    pub primary_index: Option<u32>,
    /// A list of all the parents names for the composite node. Empty if no driver has matched to
    /// this composite node spec. These are ordered according to index.
    pub parent_names: Option<Vec<String>>,
    /// The nodes in the node group.
    pub parents: Option<Vec<fidl_fuchsia_driver_framework::ParentSpec>>,
    #[deprecated = "Use `..CompositeNodeSpecInfo::EMPTY` to construct and `..` to match."]
    #[doc(hidden)]
    pub __non_exhaustive: (),
}

impl CompositeNodeSpecInfo {
    /// An empty table with every field set to `None`.
    #[allow(deprecated)]
    pub const EMPTY: Self = Self {
        name: None,
        driver: None,
        primary_index: None,
        parent_names: None,
        parents: None,
        __non_exhaustive: (),
    };
}

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

fidl_table! {
    name: CompositeNodeSpecInfo,
    members: [
        name {
            ty: fidl::encoding::UnboundedString,
            ordinal: 1,
        },
        driver {
            ty: fidl::encoding::UnboundedString,
            ordinal: 2,
        },
        primary_index {
            ty: u32,
            ordinal: 3,
        },
        parent_names {
            ty: fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>,
            ordinal: 4,
        },
        parents {
            ty: fidl::encoding::UnboundedVector<fidl_fuchsia_driver_framework::ParentSpec>,
            ordinal: 5,
        },
    ],
}

/// Information for a composite node's parent.
#[derive(Debug, Clone, PartialEq)]
pub struct CompositeParentNodeInfo {
    /// The name of the parent. Provided by the composite driver.
    pub name: Option<String>,
    /// The topological path of the node that parents the composite node.
    /// Only set if available.
    pub device: Option<String>,
    #[deprecated = "Use `..CompositeParentNodeInfo::EMPTY` to construct and `..` to match."]
    #[doc(hidden)]
    pub __non_exhaustive: (),
}

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

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

fidl_table! {
    name: CompositeParentNodeInfo,
    members: [
        name {
            ty: fidl::encoding::UnboundedString,
            ordinal: 1,
        },
        device {
            ty: fidl::encoding::UnboundedString,
            ordinal: 2,
        },
    ],
}

#[derive(Debug, Clone, PartialEq)]
pub struct DeviceInfo {
    /// (DFv1/DFv2) Unique ID identifying the device.
    pub id: Option<u64>,
    /// (DFv1/DFv2) List of ids representing parents. If more than one, this
    /// device is a composite device node.
    pub parent_ids: Option<Vec<u64>>,
    /// (DFv1/DFv2) List of ids representing children.
    pub child_ids: Option<Vec<u64>>,
    /// (DFv1/DFv2) The process KOID of the driver host the driver resides
    /// within.
    pub driver_host_koid: Option<u64>,
    /// (DFv1) The topological path of the driver.
    pub topological_path: Option<String>,
    /// (DFv1) Path to the driver shared library.
    pub bound_driver_libname: Option<String>,
    /// (DFv2) URL to the driver component manifest
    pub bound_driver_url: Option<String>,
    /// (DFv1) Properties of the device.
    pub property_list: Option<fidl_fuchsia_device_manager::DevicePropertyList>,
    /// (DFv1) Tracks the state of the device.
    pub flags: Option<DeviceFlags>,
    /// (DFv2) The collection-relative moniker of the node.
    pub moniker: Option<String>,
    /// (DFv2) Properties of the node.
    pub node_property_list: Option<Vec<fidl_fuchsia_driver_framework::NodeProperty>>,
    /// (DFv2): Component offers to the node.
    pub offer_list: Option<Vec<fidl_fuchsia_component_decl::Offer>>,
    /// (DFv1): Banjo protocol ID
    pub protocol_id: Option<u32>,
    /// (DFv1): Banjo protocol name
    pub protocol_name: Option<String>,
    #[deprecated = "Use `..DeviceInfo::EMPTY` to construct and `..` to match."]
    #[doc(hidden)]
    pub __non_exhaustive: (),
}

impl DeviceInfo {
    /// An empty table with every field set to `None`.
    #[allow(deprecated)]
    pub const EMPTY: Self = Self {
        id: None,
        parent_ids: None,
        child_ids: None,
        driver_host_koid: None,
        topological_path: None,
        bound_driver_libname: None,
        bound_driver_url: None,
        property_list: None,
        flags: None,
        moniker: None,
        node_property_list: None,
        offer_list: None,
        protocol_id: None,
        protocol_name: None,
        __non_exhaustive: (),
    };
}

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

fidl_table! {
    name: DeviceInfo,
    members: [
        id {
            ty: u64,
            ordinal: 1,
        },
        parent_ids {
            ty: fidl::encoding::UnboundedVector<u64>,
            ordinal: 2,
        },
        child_ids {
            ty: fidl::encoding::UnboundedVector<u64>,
            ordinal: 3,
        },
        driver_host_koid {
            ty: u64,
            ordinal: 4,
        },
        topological_path {
            ty: fidl::encoding::UnboundedString,
            ordinal: 5,
        },
        bound_driver_libname {
            ty: fidl::encoding::UnboundedString,
            ordinal: 6,
        },
        bound_driver_url {
            ty: fidl::encoding::UnboundedString,
            ordinal: 7,
        },
        property_list {
            ty: fidl_fuchsia_device_manager::DevicePropertyList,
            ordinal: 8,
        },
        flags {
            ty: DeviceFlags,
            ordinal: 9,
        },
        moniker {
            ty: fidl::encoding::UnboundedString,
            ordinal: 10,
        },
        node_property_list {
            ty: fidl::encoding::UnboundedVector<fidl_fuchsia_driver_framework::NodeProperty>,
            ordinal: 11,
        },
        offer_list {
            ty: fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl::Offer>,
            ordinal: 12,
        },
        protocol_id {
            ty: u32,
            ordinal: 13,
        },
        protocol_name {
            ty: fidl::encoding::UnboundedString,
            ordinal: 14,
        },
    ],
}

#[derive(Debug, Clone, PartialEq)]
pub struct DriverInfo {
    /// Path to the driver shared library.
    pub libname: Option<String>,
    /// Name of the driver, taken from the first field of the `ZIRCON_DRIVER`
    /// macro in the driver.
    pub name: Option<String>,
    /// URL of the driver component's manifest. This will only be populated if
    /// the driver is a component.
    pub url: Option<String>,
    /// Bind rules which declare set of constraints to evaluate in order to
    /// determine whether the driver indexer should bind this driver to a
    /// device.
    pub bind_rules: Option<BindRulesBytecode>,
    /// Which type of package this driver is in.
    pub package_type: Option<fidl_fuchsia_driver_index::DriverPackageType>,
    /// Hash of the package the driver belongs to.
    pub package_hash: Option<fidl_fuchsia_pkg::BlobId>,
    /// Device categories
    pub device_categories: Option<Vec<fidl_fuchsia_driver_index::DeviceCategory>>,
    #[deprecated = "Use `..DriverInfo::EMPTY` to construct and `..` to match."]
    #[doc(hidden)]
    pub __non_exhaustive: (),
}

impl DriverInfo {
    /// An empty table with every field set to `None`.
    #[allow(deprecated)]
    pub const EMPTY: Self = Self {
        libname: None,
        name: None,
        url: None,
        bind_rules: None,
        package_type: None,
        package_hash: None,
        device_categories: None,
        __non_exhaustive: (),
    };
}

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

fidl_table! {
    name: DriverInfo,
    members: [
        libname {
            ty: fidl::encoding::UnboundedString,
            ordinal: 1,
        },
        name {
            ty: fidl::encoding::UnboundedString,
            ordinal: 2,
        },
        url {
            ty: fidl::encoding::UnboundedString,
            ordinal: 3,
        },
        bind_rules {
            ty: BindRulesBytecode,
            ordinal: 4,
        },
        package_type {
            ty: fidl_fuchsia_driver_index::DriverPackageType,
            ordinal: 5,
        },
        package_hash {
            ty: fidl_fuchsia_pkg::BlobId,
            ordinal: 6,
        },
        device_categories {
            ty: fidl::encoding::UnboundedVector<fidl_fuchsia_driver_index::DeviceCategory>,
            ordinal: 7,
        },
    ],
}

/// Information for a composite node's fragment in DFv1.
#[derive(Debug, Clone, PartialEq)]
pub struct LegacyCompositeFragmentInfo {
    pub name: Option<String>,
    pub bind_rules: Option<Vec<fidl_fuchsia_device_manager::BindInstruction>>,
    pub device: Option<String>,
    #[deprecated = "Use `..LegacyCompositeFragmentInfo::EMPTY` to construct and `..` to match."]
    #[doc(hidden)]
    pub __non_exhaustive: (),
}

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

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

fidl_table! {
    name: LegacyCompositeFragmentInfo,
    members: [
        name {
            ty: fidl::encoding::UnboundedString,
            ordinal: 1,
        },
        bind_rules {
            ty: fidl::encoding::UnboundedVector<fidl_fuchsia_device_manager::BindInstruction>,
            ordinal: 2,
        },
        device {
            ty: fidl::encoding::UnboundedString,
            ordinal: 3,
        },
    ],
}

/// Information for a legacy composite node in DFv1.
#[derive(Debug, Clone, PartialEq)]
pub struct LegacyCompositeNodeInfo {
    /// A list of composite fragment information.
    pub fragments: Option<Vec<LegacyCompositeFragmentInfo>>,
    /// The node properties in the composite node.
    pub properties: Option<Vec<fidl_fuchsia_driver_framework::NodeProperty>>,
    #[deprecated = "Use `..LegacyCompositeNodeInfo::EMPTY` to construct and `..` to match."]
    #[doc(hidden)]
    pub __non_exhaustive: (),
}

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

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

fidl_table! {
    name: LegacyCompositeNodeInfo,
    members: [
        fragments {
            ty: fidl::encoding::UnboundedVector<LegacyCompositeFragmentInfo>,
            ordinal: 1,
        },
        properties {
            ty: fidl::encoding::UnboundedVector<fidl_fuchsia_driver_framework::NodeProperty>,
            ordinal: 2,
        },
    ],
}

/// Information about a driver binding to a node.
#[derive(Debug, Clone, PartialEq)]
pub struct NodeBindingInfo {
    /// Full topological name of the node that was bound to.
    pub node_name: Option<String>,
    /// The component url for the driver that bound to the node.
    pub driver_url: Option<String>,
    #[deprecated = "Use `..NodeBindingInfo::EMPTY` to construct and `..` to match."]
    #[doc(hidden)]
    pub __non_exhaustive: (),
}

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

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

fidl_table! {
    name: NodeBindingInfo,
    members: [
        node_name {
            ty: fidl::encoding::UnboundedString,
            ordinal: 1,
        },
        driver_url {
            ty: fidl::encoding::UnboundedString,
            ordinal: 2,
        },
    ],
}

#[derive(Debug, Clone, PartialEq)]
pub struct TestNodeAddArgs {
    /// Name of the node.
    pub name: Option<String>,
    /// Properties of the node.
    pub properties: Option<Vec<fidl_fuchsia_driver_framework::NodeProperty>>,
    #[deprecated = "Use `..TestNodeAddArgs::EMPTY` to construct and `..` to match."]
    #[doc(hidden)]
    pub __non_exhaustive: (),
}

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

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

fidl_table! {
    name: TestNodeAddArgs,
    members: [
        name {
            ty: fidl::encoding::UnboundedString,
            ordinal: 1,
        },
        properties {
            ty: fidl::encoding::UnboundedVector<fidl_fuchsia_driver_framework::NodeProperty>,
            ordinal: 2,
        },
    ],
}

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

impl fidl::endpoints::ProtocolMarker for CompositeInfoIteratorMarker {
    type Proxy = CompositeInfoIteratorProxy;
    type RequestStream = CompositeInfoIteratorRequestStream;
    const DEBUG_NAME: &'static str = "(anonymous) CompositeInfoIterator";
}

pub trait CompositeInfoIteratorProxyInterface: Send + Sync {
    type GetNextResponseFut: std::future::Future<Output = Result<Vec<CompositeInfo>, fidl::Error>>
        + Send;
    fn r#get_next(&self) -> Self::GetNextResponseFut;
}

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

#[cfg(target_os = "fuchsia")]
impl CompositeInfoIteratorSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <CompositeInfoIteratorMarker 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<CompositeInfoIteratorEvent, fidl::Error> {
        CompositeInfoIteratorEvent::decode(self.client.wait_for_event(deadline)?)
    }
    /// Returns up to 100 entries at a time. Return empty when no more
    /// composites are left.
    pub fn r#get_next(&self, ___deadline: zx::Time) -> Result<Vec<CompositeInfo>, fidl::Error> {
        let _response = self.client.send_query::<
                fidl::encoding::EmptyPayload,
                CompositeInfoIteratorGetNextResponse,false,true>(
                (),
                0x50af808a6e34bb96,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?
            ;
        Ok(_response.composites)
    }
}

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

impl fidl::endpoints::Proxy for CompositeInfoIteratorProxy {
    type Protocol = CompositeInfoIteratorMarker;

    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 CompositeInfoIteratorProxy {
    /// Create a new Proxy for CompositeInfoIterator
    pub fn new(channel: fidl::AsyncChannel) -> Self {
        let protocol_name =
            <CompositeInfoIteratorMarker 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 CompositeInfoIterator protocol
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> CompositeInfoIteratorEventStream {
        CompositeInfoIteratorEventStream { event_receiver: self.client.take_event_receiver() }
    }
    /// Returns up to 100 entries at a time. Return empty when no more
    /// composites are left.
    pub fn r#get_next(&self) -> fidl::client::QueryResponseFut<Vec<CompositeInfo>> {
        CompositeInfoIteratorProxyInterface::r#get_next(self)
    }
}

impl CompositeInfoIteratorProxyInterface for CompositeInfoIteratorProxy {
    type GetNextResponseFut = fidl::client::QueryResponseFut<Vec<CompositeInfo>>;
    fn r#get_next(&self) -> Self::GetNextResponseFut {
        fn _decode(
            mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<CompositeInfo>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                CompositeInfoIteratorGetNextResponse,
                true,
            >(_buf?)?;
            Ok(_response.composites)
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<CompositeInfo>, false>(
                (),
                0x50af808a6e34bb96,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }
}

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

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

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

impl futures::Stream for CompositeInfoIteratorEventStream {
    type Item = Result<CompositeInfoIteratorEvent, 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(CompositeInfoIteratorEvent::decode(buf)))
    }
}

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

impl CompositeInfoIteratorEvent {
    /// Decodes a message buffer as a [`CompositeInfoIteratorEvent`]. Transaction
    /// ID in the message must be zero; this method does not check TXID.
    fn decode(mut buf: fidl::MessageBufEtc) -> Result<CompositeInfoIteratorEvent, 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:
                    <CompositeInfoIteratorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fidl::endpoints::RequestStream for CompositeInfoIteratorRequestStream {
    type Protocol = CompositeInfoIteratorMarker;
    type ControlHandle = CompositeInfoIteratorControlHandle;

    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 {
        CompositeInfoIteratorControlHandle { 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 CompositeInfoIteratorRequestStream {
    type Item = Result<CompositeInfoIteratorRequest, 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 CompositeInfoIteratorRequestStream 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() {
                0x50af808a6e34bb96 => {
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.driver.development/CompositeInfoIteratorGetNextRequest");
                    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::<fidl::encoding::EmptyPayload>(
                        &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 =
                        CompositeInfoIteratorControlHandle { inner: this.inner.clone() };

                    Ok(CompositeInfoIteratorRequest::GetNext {
                        responder: CompositeInfoIteratorGetNextResponder {
                            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:
                        <CompositeInfoIteratorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
        })
    }
}
/// Used to page through a CompositeList.
#[derive(Debug)]
pub enum CompositeInfoIteratorRequest {
    /// Returns up to 100 entries at a time. Return empty when no more
    /// composites are left.
    GetNext { responder: CompositeInfoIteratorGetNextResponder },
}

impl CompositeInfoIteratorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_next(self) -> Option<(CompositeInfoIteratorGetNextResponder)> {
        if let CompositeInfoIteratorRequest::GetNext { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

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

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

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

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

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

    fn send_raw(
        &self,
        mut composites: &mut dyn ExactSizeIterator<Item = CompositeInfo>,
    ) -> Result<(), fidl::Error> {
        let msg = fidl::encoding::TransactionMessage {
            header: fidl::encoding::TransactionHeader::new(
                self.tx_id,
                self.ordinal,
                fidl::encoding::DynamicFlags::empty(),
            ),
            body: (fidl::encoding::Iterator(composites),),
        };

        fidl::encoding::with_tls_encode_buf(|bytes, handles| {
            fidl::duration_begin!("fidl", "encode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.driver.development/CompositeInfoIteratorGetNextResponse");
            fidl::encoding::Encoder::encode::<
                fidl::encoding::TransactionMessageType<CompositeInfoIteratorGetNextResponse>,
            >(bytes, handles, 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 CompositeNodeSpecIteratorMarker;

impl fidl::endpoints::ProtocolMarker for CompositeNodeSpecIteratorMarker {
    type Proxy = CompositeNodeSpecIteratorProxy;
    type RequestStream = CompositeNodeSpecIteratorRequestStream;
    const DEBUG_NAME: &'static str = "(anonymous) CompositeNodeSpecIterator";
}

pub trait CompositeNodeSpecIteratorProxyInterface: Send + Sync {
    type GetNextResponseFut: std::future::Future<Output = Result<Vec<CompositeNodeSpecInfo>, fidl::Error>>
        + Send;
    fn r#get_next(&self) -> Self::GetNextResponseFut;
}

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

#[cfg(target_os = "fuchsia")]
impl CompositeNodeSpecIteratorSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <CompositeNodeSpecIteratorMarker 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<CompositeNodeSpecIteratorEvent, fidl::Error> {
        CompositeNodeSpecIteratorEvent::decode(self.client.wait_for_event(deadline)?)
    }
    /// Return empty when no more node groups are left.
    pub fn r#get_next(
        &self,
        ___deadline: zx::Time,
    ) -> Result<Vec<CompositeNodeSpecInfo>, fidl::Error> {
        let _response = self.client.send_query::<
                fidl::encoding::EmptyPayload,
                CompositeNodeSpecIteratorGetNextResponse,false,true>(
                (),
                0x32fd110355479f71,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?
            ;
        Ok(_response.specs)
    }
}

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

impl fidl::endpoints::Proxy for CompositeNodeSpecIteratorProxy {
    type Protocol = CompositeNodeSpecIteratorMarker;

    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 CompositeNodeSpecIteratorProxy {
    /// Create a new Proxy for CompositeNodeSpecIterator
    pub fn new(channel: fidl::AsyncChannel) -> Self {
        let protocol_name =
            <CompositeNodeSpecIteratorMarker 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 CompositeNodeSpecIterator protocol
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> CompositeNodeSpecIteratorEventStream {
        CompositeNodeSpecIteratorEventStream { event_receiver: self.client.take_event_receiver() }
    }
    /// Return empty when no more node groups are left.
    pub fn r#get_next(&self) -> fidl::client::QueryResponseFut<Vec<CompositeNodeSpecInfo>> {
        CompositeNodeSpecIteratorProxyInterface::r#get_next(self)
    }
}

impl CompositeNodeSpecIteratorProxyInterface for CompositeNodeSpecIteratorProxy {
    type GetNextResponseFut = fidl::client::QueryResponseFut<Vec<CompositeNodeSpecInfo>>;
    fn r#get_next(&self) -> Self::GetNextResponseFut {
        fn _decode(
            mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<CompositeNodeSpecInfo>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                CompositeNodeSpecIteratorGetNextResponse,
                true,
            >(_buf?)?;
            Ok(_response.specs)
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            Vec<CompositeNodeSpecInfo>,
            false,
        >(
            (),
            0x32fd110355479f71,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

impl futures::Stream for CompositeNodeSpecIteratorEventStream {
    type Item = Result<CompositeNodeSpecIteratorEvent, 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(CompositeNodeSpecIteratorEvent::decode(buf)))
    }
}

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

impl CompositeNodeSpecIteratorEvent {
    /// Decodes a message buffer as a [`CompositeNodeSpecIteratorEvent`]. Transaction
    /// ID in the message must be zero; this method does not check TXID.
    fn decode(mut buf: fidl::MessageBufEtc) -> Result<CompositeNodeSpecIteratorEvent, 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:
                    <CompositeNodeSpecIteratorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fidl::endpoints::RequestStream for CompositeNodeSpecIteratorRequestStream {
    type Protocol = CompositeNodeSpecIteratorMarker;
    type ControlHandle = CompositeNodeSpecIteratorControlHandle;

    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 {
        CompositeNodeSpecIteratorControlHandle { 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 CompositeNodeSpecIteratorRequestStream {
    type Item = Result<CompositeNodeSpecIteratorRequest, 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 CompositeNodeSpecIteratorRequestStream 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() {
                0x32fd110355479f71 => {
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.driver.development/CompositeNodeSpecIteratorGetNextRequest");
                    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::<fidl::encoding::EmptyPayload>(&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 = CompositeNodeSpecIteratorControlHandle {
                        inner: this.inner.clone(),
                    };

                    Ok(CompositeNodeSpecIteratorRequest::GetNext {
                            responder:CompositeNodeSpecIteratorGetNextResponder {
                                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: <CompositeNodeSpecIteratorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
        })
    }
}
#[derive(Debug)]
pub enum CompositeNodeSpecIteratorRequest {
    /// Return empty when no more node groups are left.
    GetNext { responder: CompositeNodeSpecIteratorGetNextResponder },
}

impl CompositeNodeSpecIteratorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_next(self) -> Option<(CompositeNodeSpecIteratorGetNextResponder)> {
        if let CompositeNodeSpecIteratorRequest::GetNext { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

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

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

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

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

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

    fn send_raw(
        &self,
        mut specs: &mut dyn ExactSizeIterator<Item = CompositeNodeSpecInfo>,
    ) -> Result<(), fidl::Error> {
        let msg = fidl::encoding::TransactionMessage {
            header: fidl::encoding::TransactionHeader::new(
                self.tx_id,
                self.ordinal,
                fidl::encoding::DynamicFlags::empty(),
            ),
            body: (fidl::encoding::Iterator(specs),),
        };

        fidl::encoding::with_tls_encode_buf(|bytes, handles| {
            fidl::duration_begin!("fidl", "encode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.driver.development/CompositeNodeSpecIteratorGetNextResponse");
            fidl::encoding::Encoder::encode::<
                fidl::encoding::TransactionMessageType<CompositeNodeSpecIteratorGetNextResponse>,
            >(bytes, handles, 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 DeviceInfoIteratorMarker;

impl fidl::endpoints::ProtocolMarker for DeviceInfoIteratorMarker {
    type Proxy = DeviceInfoIteratorProxy;
    type RequestStream = DeviceInfoIteratorRequestStream;
    const DEBUG_NAME: &'static str = "(anonymous) DeviceInfoIterator";
}

pub trait DeviceInfoIteratorProxyInterface: Send + Sync {
    type GetNextResponseFut: std::future::Future<Output = Result<Vec<DeviceInfo>, fidl::Error>>
        + Send;
    fn r#get_next(&self) -> Self::GetNextResponseFut;
}

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

#[cfg(target_os = "fuchsia")]
impl DeviceInfoIteratorSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <DeviceInfoIteratorMarker 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<DeviceInfoIteratorEvent, fidl::Error> {
        DeviceInfoIteratorEvent::decode(self.client.wait_for_event(deadline)?)
    }
    /// Return 0 devices when no more entries left.
    pub fn r#get_next(&self, ___deadline: zx::Time) -> Result<Vec<DeviceInfo>, fidl::Error> {
        let _response = self.client.send_query::<
                fidl::encoding::EmptyPayload,
                DeviceInfoIteratorGetNextResponse,false,true>(
                (),
                0x3e24784022ec70f7,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?
            ;
        Ok(_response.drivers)
    }
}

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

impl fidl::endpoints::Proxy for DeviceInfoIteratorProxy {
    type Protocol = DeviceInfoIteratorMarker;

    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 DeviceInfoIteratorProxy {
    /// Create a new Proxy for DeviceInfoIterator
    pub fn new(channel: fidl::AsyncChannel) -> Self {
        let protocol_name =
            <DeviceInfoIteratorMarker 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 DeviceInfoIterator protocol
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> DeviceInfoIteratorEventStream {
        DeviceInfoIteratorEventStream { event_receiver: self.client.take_event_receiver() }
    }
    /// Return 0 devices when no more entries left.
    pub fn r#get_next(&self) -> fidl::client::QueryResponseFut<Vec<DeviceInfo>> {
        DeviceInfoIteratorProxyInterface::r#get_next(self)
    }
}

impl DeviceInfoIteratorProxyInterface for DeviceInfoIteratorProxy {
    type GetNextResponseFut = fidl::client::QueryResponseFut<Vec<DeviceInfo>>;
    fn r#get_next(&self) -> Self::GetNextResponseFut {
        fn _decode(
            mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<DeviceInfo>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DeviceInfoIteratorGetNextResponse,
                true,
            >(_buf?)?;
            Ok(_response.drivers)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<DeviceInfo>, false>(
            (),
            0x3e24784022ec70f7,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

impl futures::Stream for DeviceInfoIteratorEventStream {
    type Item = Result<DeviceInfoIteratorEvent, 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(DeviceInfoIteratorEvent::decode(buf)))
    }
}

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

impl DeviceInfoIteratorEvent {
    /// Decodes a message buffer as a [`DeviceInfoIteratorEvent`]. Transaction
    /// ID in the message must be zero; this method does not check TXID.
    fn decode(mut buf: fidl::MessageBufEtc) -> Result<DeviceInfoIteratorEvent, 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:
                    <DeviceInfoIteratorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fidl::endpoints::RequestStream for DeviceInfoIteratorRequestStream {
    type Protocol = DeviceInfoIteratorMarker;
    type ControlHandle = DeviceInfoIteratorControlHandle;

    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 {
        DeviceInfoIteratorControlHandle { 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 DeviceInfoIteratorRequestStream {
    type Item = Result<DeviceInfoIteratorRequest, 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 DeviceInfoIteratorRequestStream 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() {
                0x3e24784022ec70f7 => {
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.driver.development/DeviceInfoIteratorGetNextRequest");
                    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::<fidl::encoding::EmptyPayload>(
                        &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 =
                        DeviceInfoIteratorControlHandle { inner: this.inner.clone() };

                    Ok(DeviceInfoIteratorRequest::GetNext {
                        responder: DeviceInfoIteratorGetNextResponder {
                            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:
                        <DeviceInfoIteratorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
        })
    }
}
#[derive(Debug)]
pub enum DeviceInfoIteratorRequest {
    /// Return 0 devices when no more entries left.
    GetNext { responder: DeviceInfoIteratorGetNextResponder },
}

impl DeviceInfoIteratorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_next(self) -> Option<(DeviceInfoIteratorGetNextResponder)> {
        if let DeviceInfoIteratorRequest::GetNext { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

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

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

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

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

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

    fn send_raw(
        &self,
        mut drivers: &mut dyn ExactSizeIterator<Item = DeviceInfo>,
    ) -> Result<(), fidl::Error> {
        let msg = fidl::encoding::TransactionMessage {
            header: fidl::encoding::TransactionHeader::new(
                self.tx_id,
                self.ordinal,
                fidl::encoding::DynamicFlags::empty(),
            ),
            body: (fidl::encoding::Iterator(drivers),),
        };

        fidl::encoding::with_tls_encode_buf(|bytes, handles| {
            fidl::duration_begin!("fidl", "encode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.driver.development/DeviceInfoIteratorGetNextResponse");
            fidl::encoding::Encoder::encode::<
                fidl::encoding::TransactionMessageType<DeviceInfoIteratorGetNextResponse>,
            >(bytes, handles, 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 DriverDevelopmentMarker;

impl fidl::endpoints::ProtocolMarker for DriverDevelopmentMarker {
    type Proxy = DriverDevelopmentProxy;
    type RequestStream = DriverDevelopmentRequestStream;
    const DEBUG_NAME: &'static str = "fuchsia.driver.development.DriverDevelopment";
}
impl fidl::endpoints::DiscoverableProtocolMarker for DriverDevelopmentMarker {}
pub type DriverDevelopmentRestartDriverHostsResult = Result<u32, i32>;
pub type DriverDevelopmentBindAllUnboundNodesResult = Result<Vec<NodeBindingInfo>, i32>;
pub type DriverDevelopmentAddTestNodeResult = Result<(), fidl_fuchsia_driver_framework::NodeError>;
pub type DriverDevelopmentRemoveTestNodeResult = Result<(), i32>;

pub trait DriverDevelopmentProxyInterface: Send + Sync {
    fn r#get_driver_info(
        &self,
        driver_filter: &mut dyn ExactSizeIterator<Item = &str>,
        iterator: fidl::endpoints::ServerEnd<DriverInfoIteratorMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#get_composite_node_specs(
        &self,
        name_filter: Option<&str>,
        iterator: fidl::endpoints::ServerEnd<CompositeNodeSpecIteratorMarker>,
    ) -> Result<(), fidl::Error>;
    type RestartDriverHostsResponseFut: std::future::Future<Output = Result<DriverDevelopmentRestartDriverHostsResult, fidl::Error>>
        + Send;
    fn r#restart_driver_hosts(&self, driver_path: &str) -> Self::RestartDriverHostsResponseFut;
    fn r#get_device_info(
        &self,
        device_filter: &mut dyn ExactSizeIterator<Item = &str>,
        iterator: fidl::endpoints::ServerEnd<DeviceInfoIteratorMarker>,
        exact_match: bool,
    ) -> Result<(), fidl::Error>;
    fn r#get_composite_info(
        &self,
        iterator: fidl::endpoints::ServerEnd<CompositeInfoIteratorMarker>,
    ) -> Result<(), fidl::Error>;
    type BindAllUnboundNodesResponseFut: std::future::Future<
            Output = Result<DriverDevelopmentBindAllUnboundNodesResult, fidl::Error>,
        > + Send;
    fn r#bind_all_unbound_nodes(&self) -> Self::BindAllUnboundNodesResponseFut;
    type IsDfv2ResponseFut: std::future::Future<Output = Result<bool, fidl::Error>> + Send;
    fn r#is_dfv2(&self) -> Self::IsDfv2ResponseFut;
    type AddTestNodeResponseFut: std::future::Future<Output = Result<DriverDevelopmentAddTestNodeResult, fidl::Error>>
        + Send;
    fn r#add_test_node(&self, args: TestNodeAddArgs) -> Self::AddTestNodeResponseFut;
    type RemoveTestNodeResponseFut: std::future::Future<Output = Result<DriverDevelopmentRemoveTestNodeResult, fidl::Error>>
        + Send;
    fn r#remove_test_node(&self, name: &str) -> Self::RemoveTestNodeResponseFut;
}

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

#[cfg(target_os = "fuchsia")]
impl DriverDevelopmentSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <DriverDevelopmentMarker 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<DriverDevelopmentEvent, fidl::Error> {
        DriverDevelopmentEvent::decode(self.client.wait_for_event(deadline)?)
    }
    /// Returns a list of all drivers that are known to the system.
    /// If a |driver_filter| is provided, the returned list will be filtered to
    /// only include drivers specified in the filter.
    ///
    /// |iterator| is closed with following epitaphs on error:
    /// ZX_ERR_NOT_FOUND indicates that there is no driver matching the given path for at least
    /// one driver in |driver_filter|.
    /// ZX_ERR_BUFFER_TOO_SMALL indicates that the driver's bind program is longer than the
    /// maximum number of instructions (BIND_PROGRAM_INSTRUCTIONS_MAX).
    pub fn r#get_driver_info(
        &self,
        mut driver_filter: &mut dyn ExactSizeIterator<Item = &str>,
        mut iterator: fidl::endpoints::ServerEnd<DriverInfoIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DriverIndexGetDriverInfoRequest, false>(
            (fidl::encoding::Iterator(driver_filter), iterator),
            0x5f51f1ceaa350c28,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    /// Returns a list of all composite node specs that are known to the system.
    /// If a |name_filter| is provided, the returned list will only include 1 spec,
    /// the one with that exact name.
    ///
    /// |iterator| is closed with following epitaphs on error:
    /// ZX_ERR_NOT_FOUND indicates that there are no specs or if a |name_filter| is provided,
    /// that there are no specs with that name.
    pub fn r#get_composite_node_specs(
        &self,
        mut name_filter: Option<&str>,
        mut iterator: fidl::endpoints::ServerEnd<CompositeNodeSpecIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DriverIndexGetCompositeNodeSpecsRequest, false>(
            (name_filter, iterator),
            0x43104254014654e6,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    /// Restarts all driver hosts containing the driver specified by `driver path`, and returns the
    /// number of driver hosts that were restarted.
    pub fn r#restart_driver_hosts(
        &self,
        mut driver_path: &str,
        ___deadline: zx::Time,
    ) -> Result<DriverDevelopmentRestartDriverHostsResult, fidl::Error> {
        let _response = self.client.send_query::<
                DriverDevelopmentRestartDriverHostsRequest,
                fidl::encoding::ResultType<DriverDevelopmentRestartDriverHostsResponse, i32>,false,false>(
                (driver_path,),
                0x41f109f152ecfe00,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?
            ;
        Ok(_response.map(|x| x.count))
    }
    /// Returns the list of devices that are running on the system.
    ///
    /// If a |device_filter| is provided, the returned list will be filtered to
    /// only include devices specified in the filter. If |exact_match| is true,
    /// then the filter must exactly match a device's topological path;
    /// otherwise, it performs a substring match. The list will be empty if no
    /// devices match the filter.
    ///
    /// |iterator| is closed with following epitaphs on error:
    /// ZX_ERR_BAD_PATH indicates that the given path is not valid.
    /// ZX_ERR_BUFFER_TOO_SMALL indicates either that the given path is too long,
    /// or that the device has more than the maximum number of properties (PROPERTIES_MAX).
    pub fn r#get_device_info(
        &self,
        mut device_filter: &mut dyn ExactSizeIterator<Item = &str>,
        mut iterator: fidl::endpoints::ServerEnd<DeviceInfoIteratorMarker>,
        mut exact_match: bool,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DriverDevelopmentGetDeviceInfoRequest, false>(
            (fidl::encoding::Iterator(device_filter), iterator, exact_match),
            0x47c15054d1954812,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    /// Returns the list of composites in the system. This includes composites
    /// that are not yet assembled and added into the node topology.
    pub fn r#get_composite_info(
        &self,
        mut iterator: fidl::endpoints::ServerEnd<CompositeInfoIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DriverDevelopmentGetCompositeInfoRequest, false>(
            (iterator,),
            0x7b6e681d998a88,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    /// (DFv2) Attempts to bind all unbound nodes in the topology.
    /// Returns new successful binds.
    pub fn r#bind_all_unbound_nodes(
        &self,
        ___deadline: zx::Time,
    ) -> Result<DriverDevelopmentBindAllUnboundNodesResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                DriverDevelopmentBindAllUnboundNodesResponse,
                i32,
            >, false, true>(
                (),
                0xaeb067b90843cb6,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.binding_result))
    }
    pub fn r#is_dfv2(&self, ___deadline: zx::Time) -> Result<bool, fidl::Error> {
        let _response = self.client.send_query::<
                fidl::encoding::EmptyPayload,
                DriverDevelopmentIsDfv2Response,false,false>(
                (),
                0x4f8e78c763350ee8,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?
            ;
        Ok(_response.response)
    }
    /// (DFv2) Adds test node under the root node.
    pub fn r#add_test_node(
        &self,
        mut args: TestNodeAddArgs,
        ___deadline: zx::Time,
    ) -> Result<DriverDevelopmentAddTestNodeResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<DriverDevelopmentAddTestNodeRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_driver_framework::NodeError,
            >, false, false>(
                (&args,),
                0x7462b4a0ecbd6903,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }
    /// (DFv2) Removes the test node. The node is removed asynchronously and is
    /// not guaranteed to be removed by the time this returns.
    pub fn r#remove_test_node(
        &self,
        mut name: &str,
        ___deadline: zx::Time,
    ) -> Result<DriverDevelopmentRemoveTestNodeResult, fidl::Error> {
        let _response = self.client.send_query::<
                DriverDevelopmentRemoveTestNodeRequest,
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,false,false>(
                (name,),
                0x674bca94f5bd93e6,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?
            ;
        Ok(_response.map(|x| x))
    }
}

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

impl fidl::endpoints::Proxy for DriverDevelopmentProxy {
    type Protocol = DriverDevelopmentMarker;

    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 DriverDevelopmentProxy {
    /// Create a new Proxy for DriverDevelopment
    pub fn new(channel: fidl::AsyncChannel) -> Self {
        let protocol_name =
            <DriverDevelopmentMarker 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 DriverDevelopment protocol
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> DriverDevelopmentEventStream {
        DriverDevelopmentEventStream { event_receiver: self.client.take_event_receiver() }
    }
    /// Returns a list of all drivers that are known to the system.
    /// If a |driver_filter| is provided, the returned list will be filtered to
    /// only include drivers specified in the filter.
    ///
    /// |iterator| is closed with following epitaphs on error:
    /// ZX_ERR_NOT_FOUND indicates that there is no driver matching the given path for at least
    /// one driver in |driver_filter|.
    /// ZX_ERR_BUFFER_TOO_SMALL indicates that the driver's bind program is longer than the
    /// maximum number of instructions (BIND_PROGRAM_INSTRUCTIONS_MAX).
    pub fn r#get_driver_info(
        &self,
        mut driver_filter: &mut dyn ExactSizeIterator<Item = &str>,
        mut iterator: fidl::endpoints::ServerEnd<DriverInfoIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        DriverDevelopmentProxyInterface::r#get_driver_info(self, driver_filter, iterator)
    }
    /// Returns a list of all composite node specs that are known to the system.
    /// If a |name_filter| is provided, the returned list will only include 1 spec,
    /// the one with that exact name.
    ///
    /// |iterator| is closed with following epitaphs on error:
    /// ZX_ERR_NOT_FOUND indicates that there are no specs or if a |name_filter| is provided,
    /// that there are no specs with that name.
    pub fn r#get_composite_node_specs(
        &self,
        mut name_filter: Option<&str>,
        mut iterator: fidl::endpoints::ServerEnd<CompositeNodeSpecIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        DriverDevelopmentProxyInterface::r#get_composite_node_specs(self, name_filter, iterator)
    }
    /// Restarts all driver hosts containing the driver specified by `driver path`, and returns the
    /// number of driver hosts that were restarted.
    pub fn r#restart_driver_hosts(
        &self,
        mut driver_path: &str,
    ) -> fidl::client::QueryResponseFut<DriverDevelopmentRestartDriverHostsResult> {
        DriverDevelopmentProxyInterface::r#restart_driver_hosts(self, driver_path)
    }
    /// Returns the list of devices that are running on the system.
    ///
    /// If a |device_filter| is provided, the returned list will be filtered to
    /// only include devices specified in the filter. If |exact_match| is true,
    /// then the filter must exactly match a device's topological path;
    /// otherwise, it performs a substring match. The list will be empty if no
    /// devices match the filter.
    ///
    /// |iterator| is closed with following epitaphs on error:
    /// ZX_ERR_BAD_PATH indicates that the given path is not valid.
    /// ZX_ERR_BUFFER_TOO_SMALL indicates either that the given path is too long,
    /// or that the device has more than the maximum number of properties (PROPERTIES_MAX).
    pub fn r#get_device_info(
        &self,
        mut device_filter: &mut dyn ExactSizeIterator<Item = &str>,
        mut iterator: fidl::endpoints::ServerEnd<DeviceInfoIteratorMarker>,
        mut exact_match: bool,
    ) -> Result<(), fidl::Error> {
        DriverDevelopmentProxyInterface::r#get_device_info(
            self,
            device_filter,
            iterator,
            exact_match,
        )
    }
    /// Returns the list of composites in the system. This includes composites
    /// that are not yet assembled and added into the node topology.
    pub fn r#get_composite_info(
        &self,
        mut iterator: fidl::endpoints::ServerEnd<CompositeInfoIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        DriverDevelopmentProxyInterface::r#get_composite_info(self, iterator)
    }
    /// (DFv2) Attempts to bind all unbound nodes in the topology.
    /// Returns new successful binds.
    pub fn r#bind_all_unbound_nodes(
        &self,
    ) -> fidl::client::QueryResponseFut<DriverDevelopmentBindAllUnboundNodesResult> {
        DriverDevelopmentProxyInterface::r#bind_all_unbound_nodes(self)
    }
    pub fn r#is_dfv2(&self) -> fidl::client::QueryResponseFut<bool> {
        DriverDevelopmentProxyInterface::r#is_dfv2(self)
    }
    /// (DFv2) Adds test node under the root node.
    pub fn r#add_test_node(
        &self,
        mut args: TestNodeAddArgs,
    ) -> fidl::client::QueryResponseFut<DriverDevelopmentAddTestNodeResult> {
        DriverDevelopmentProxyInterface::r#add_test_node(self, args)
    }
    /// (DFv2) Removes the test node. The node is removed asynchronously and is
    /// not guaranteed to be removed by the time this returns.
    pub fn r#remove_test_node(
        &self,
        mut name: &str,
    ) -> fidl::client::QueryResponseFut<DriverDevelopmentRemoveTestNodeResult> {
        DriverDevelopmentProxyInterface::r#remove_test_node(self, name)
    }
}

impl DriverDevelopmentProxyInterface for DriverDevelopmentProxy {
    fn r#get_driver_info(
        &self,
        mut driver_filter: &mut dyn ExactSizeIterator<Item = &str>,
        mut iterator: fidl::endpoints::ServerEnd<DriverInfoIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DriverIndexGetDriverInfoRequest, false>(
            (fidl::encoding::Iterator(driver_filter), iterator),
            0x5f51f1ceaa350c28,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    fn r#get_composite_node_specs(
        &self,
        mut name_filter: Option<&str>,
        mut iterator: fidl::endpoints::ServerEnd<CompositeNodeSpecIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DriverIndexGetCompositeNodeSpecsRequest, false>(
            (name_filter, iterator),
            0x43104254014654e6,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    type RestartDriverHostsResponseFut =
        fidl::client::QueryResponseFut<DriverDevelopmentRestartDriverHostsResult>;
    fn r#restart_driver_hosts(&self, mut driver_path: &str) -> Self::RestartDriverHostsResponseFut {
        fn _decode(
            mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
        ) -> Result<DriverDevelopmentRestartDriverHostsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<DriverDevelopmentRestartDriverHostsResponse, i32>,
                false,
            >(_buf?)?;
            Ok(_response.map(|x| x.count))
        }
        self.client.send_query_and_decode::<
            DriverDevelopmentRestartDriverHostsRequest,
            DriverDevelopmentRestartDriverHostsResult,
            false,
        >(
            (driver_path,),
            0x41f109f152ecfe00,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
    fn r#get_device_info(
        &self,
        mut device_filter: &mut dyn ExactSizeIterator<Item = &str>,
        mut iterator: fidl::endpoints::ServerEnd<DeviceInfoIteratorMarker>,
        mut exact_match: bool,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DriverDevelopmentGetDeviceInfoRequest, false>(
            (fidl::encoding::Iterator(device_filter), iterator, exact_match),
            0x47c15054d1954812,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    fn r#get_composite_info(
        &self,
        mut iterator: fidl::endpoints::ServerEnd<CompositeInfoIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DriverDevelopmentGetCompositeInfoRequest, false>(
            (iterator,),
            0x7b6e681d998a88,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    type BindAllUnboundNodesResponseFut =
        fidl::client::QueryResponseFut<DriverDevelopmentBindAllUnboundNodesResult>;
    fn r#bind_all_unbound_nodes(&self) -> Self::BindAllUnboundNodesResponseFut {
        fn _decode(
            mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
        ) -> Result<DriverDevelopmentBindAllUnboundNodesResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<DriverDevelopmentBindAllUnboundNodesResponse, i32>,
                true,
            >(_buf?)?;
            Ok(_response.map(|x| x.binding_result))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            DriverDevelopmentBindAllUnboundNodesResult,
            false,
        >(
            (),
            0xaeb067b90843cb6,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
    type IsDfv2ResponseFut = fidl::client::QueryResponseFut<bool>;
    fn r#is_dfv2(&self) -> Self::IsDfv2ResponseFut {
        fn _decode(
            mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
        ) -> Result<bool, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DriverDevelopmentIsDfv2Response,
                false,
            >(_buf?)?;
            Ok(_response.response)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, bool, false>(
            (),
            0x4f8e78c763350ee8,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
    type AddTestNodeResponseFut =
        fidl::client::QueryResponseFut<DriverDevelopmentAddTestNodeResult>;
    fn r#add_test_node(&self, mut args: TestNodeAddArgs) -> Self::AddTestNodeResponseFut {
        fn _decode(
            mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
        ) -> Result<DriverDevelopmentAddTestNodeResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_driver_framework::NodeError,
                >,
                false,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            DriverDevelopmentAddTestNodeRequest,
            DriverDevelopmentAddTestNodeResult,
            false,
        >(
            (&args,),
            0x7462b4a0ecbd6903,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
    type RemoveTestNodeResponseFut =
        fidl::client::QueryResponseFut<DriverDevelopmentRemoveTestNodeResult>;
    fn r#remove_test_node(&self, mut name: &str) -> Self::RemoveTestNodeResponseFut {
        fn _decode(
            mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
        ) -> Result<DriverDevelopmentRemoveTestNodeResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                false,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            DriverDevelopmentRemoveTestNodeRequest,
            DriverDevelopmentRemoveTestNodeResult,
            false,
        >(
            (name,),
            0x674bca94f5bd93e6,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

impl futures::Stream for DriverDevelopmentEventStream {
    type Item = Result<DriverDevelopmentEvent, 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(DriverDevelopmentEvent::decode(buf)))
    }
}

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

impl DriverDevelopmentEvent {
    /// Decodes a message buffer as a [`DriverDevelopmentEvent`]. Transaction
    /// ID in the message must be zero; this method does not check TXID.
    fn decode(mut buf: fidl::MessageBufEtc) -> Result<DriverDevelopmentEvent, 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:
                    <DriverDevelopmentMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fidl::endpoints::RequestStream for DriverDevelopmentRequestStream {
    type Protocol = DriverDevelopmentMarker;
    type ControlHandle = DriverDevelopmentControlHandle;

    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 {
        DriverDevelopmentControlHandle { 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 DriverDevelopmentRequestStream {
    type Item = Result<DriverDevelopmentRequest, 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 DriverDevelopmentRequestStream 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() {
                0x5f51f1ceaa350c28 => {
                    let mut req = fidl::new_empty!(DriverIndexGetDriverInfoRequest);
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.driver.development/DriverDevelopmentGetDriverInfoRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    fidl::encoding::maybe_overflowing_decode::<DriverIndexGetDriverInfoRequest>(
                        &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 =
                        DriverDevelopmentControlHandle { inner: this.inner.clone() };

                    Ok(DriverDevelopmentRequest::GetDriverInfo {
                        driver_filter: req.driver_filter,
                        iterator: req.iterator,

                        control_handle,
                    })
                }
                0x43104254014654e6 => {
                    let mut req = fidl::new_empty!(DriverIndexGetCompositeNodeSpecsRequest);
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.driver.development/DriverDevelopmentGetCompositeNodeSpecsRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    fidl::encoding::maybe_overflowing_decode::<
                        DriverIndexGetCompositeNodeSpecsRequest,
                    >(&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 =
                        DriverDevelopmentControlHandle { inner: this.inner.clone() };

                    Ok(DriverDevelopmentRequest::GetCompositeNodeSpecs {
                        name_filter: req.name_filter,
                        iterator: req.iterator,

                        control_handle,
                    })
                }
                0x41f109f152ecfe00 => {
                    let mut req = fidl::new_empty!(DriverDevelopmentRestartDriverHostsRequest);
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.driver.development/DriverDevelopmentRestartDriverHostsRequest");
                    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::<
                        DriverDevelopmentRestartDriverHostsRequest,
                    >(&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 =
                        DriverDevelopmentControlHandle { inner: this.inner.clone() };

                    Ok(DriverDevelopmentRequest::RestartDriverHosts {
                        driver_path: req.driver_path,

                        responder: DriverDevelopmentRestartDriverHostsResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id(),
                            ordinal: header.ordinal(),
                        },
                    })
                }
                0x47c15054d1954812 => {
                    let mut req = fidl::new_empty!(DriverDevelopmentGetDeviceInfoRequest);
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.driver.development/DriverDevelopmentGetDeviceInfoRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    fidl::encoding::maybe_overflowing_decode::<
                        DriverDevelopmentGetDeviceInfoRequest,
                    >(&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 =
                        DriverDevelopmentControlHandle { inner: this.inner.clone() };

                    Ok(DriverDevelopmentRequest::GetDeviceInfo {
                        device_filter: req.device_filter,
                        iterator: req.iterator,
                        exact_match: req.exact_match,

                        control_handle,
                    })
                }
                0x7b6e681d998a88 => {
                    let mut req = fidl::new_empty!(DriverDevelopmentGetCompositeInfoRequest);
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.driver.development/DriverDevelopmentGetCompositeInfoRequest");
                    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::<DriverDevelopmentGetCompositeInfoRequest>(
                        &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 =
                        DriverDevelopmentControlHandle { inner: this.inner.clone() };

                    Ok(DriverDevelopmentRequest::GetCompositeInfo {
                        iterator: req.iterator,

                        control_handle,
                    })
                }
                0xaeb067b90843cb6 => {
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.driver.development/DriverDevelopmentBindAllUnboundNodesRequest");
                    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::<fidl::encoding::EmptyPayload>(
                        &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 =
                        DriverDevelopmentControlHandle { inner: this.inner.clone() };

                    Ok(DriverDevelopmentRequest::BindAllUnboundNodes {
                        responder: DriverDevelopmentBindAllUnboundNodesResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id(),
                            ordinal: header.ordinal(),
                        },
                    })
                }
                0x4f8e78c763350ee8 => {
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.driver.development/DriverDevelopmentIsDfv2Request");
                    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::<fidl::encoding::EmptyPayload>(
                        &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 =
                        DriverDevelopmentControlHandle { inner: this.inner.clone() };

                    Ok(DriverDevelopmentRequest::IsDfv2 {
                        responder: DriverDevelopmentIsDfv2Responder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id(),
                            ordinal: header.ordinal(),
                        },
                    })
                }
                0x7462b4a0ecbd6903 => {
                    let mut req = fidl::new_empty!(DriverDevelopmentAddTestNodeRequest);
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.driver.development/DriverDevelopmentAddTestNodeRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    fidl::encoding::maybe_overflowing_decode::<DriverDevelopmentAddTestNodeRequest>(
                        &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 =
                        DriverDevelopmentControlHandle { inner: this.inner.clone() };

                    Ok(DriverDevelopmentRequest::AddTestNode {
                        args: req.args,

                        responder: DriverDevelopmentAddTestNodeResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id(),
                            ordinal: header.ordinal(),
                        },
                    })
                }
                0x674bca94f5bd93e6 => {
                    let mut req = fidl::new_empty!(DriverDevelopmentRemoveTestNodeRequest);
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.driver.development/DriverDevelopmentRemoveTestNodeRequest");
                    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::<DriverDevelopmentRemoveTestNodeRequest>(
                        &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 =
                        DriverDevelopmentControlHandle { inner: this.inner.clone() };

                    Ok(DriverDevelopmentRequest::RemoveTestNode {
                        name: req.name,

                        responder: DriverDevelopmentRemoveTestNodeResponder {
                            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:
                        <DriverDevelopmentMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
        })
    }
}
/// Interface for developing and debugging drivers.
/// This interface should only be used for development and disabled in release builds.
#[derive(Debug)]
pub enum DriverDevelopmentRequest {
    /// Returns a list of all drivers that are known to the system.
    /// If a |driver_filter| is provided, the returned list will be filtered to
    /// only include drivers specified in the filter.
    ///
    /// |iterator| is closed with following epitaphs on error:
    /// ZX_ERR_NOT_FOUND indicates that there is no driver matching the given path for at least
    /// one driver in |driver_filter|.
    /// ZX_ERR_BUFFER_TOO_SMALL indicates that the driver's bind program is longer than the
    /// maximum number of instructions (BIND_PROGRAM_INSTRUCTIONS_MAX).
    GetDriverInfo {
        driver_filter: Vec<String>,
        iterator: fidl::endpoints::ServerEnd<DriverInfoIteratorMarker>,
        control_handle: DriverDevelopmentControlHandle,
    },
    /// Returns a list of all composite node specs that are known to the system.
    /// If a |name_filter| is provided, the returned list will only include 1 spec,
    /// the one with that exact name.
    ///
    /// |iterator| is closed with following epitaphs on error:
    /// ZX_ERR_NOT_FOUND indicates that there are no specs or if a |name_filter| is provided,
    /// that there are no specs with that name.
    GetCompositeNodeSpecs {
        name_filter: Option<String>,
        iterator: fidl::endpoints::ServerEnd<CompositeNodeSpecIteratorMarker>,
        control_handle: DriverDevelopmentControlHandle,
    },
    /// Restarts all driver hosts containing the driver specified by `driver path`, and returns the
    /// number of driver hosts that were restarted.
    RestartDriverHosts {
        driver_path: String,
        responder: DriverDevelopmentRestartDriverHostsResponder,
    },
    /// Returns the list of devices that are running on the system.
    ///
    /// If a |device_filter| is provided, the returned list will be filtered to
    /// only include devices specified in the filter. If |exact_match| is true,
    /// then the filter must exactly match a device's topological path;
    /// otherwise, it performs a substring match. The list will be empty if no
    /// devices match the filter.
    ///
    /// |iterator| is closed with following epitaphs on error:
    /// ZX_ERR_BAD_PATH indicates that the given path is not valid.
    /// ZX_ERR_BUFFER_TOO_SMALL indicates either that the given path is too long,
    /// or that the device has more than the maximum number of properties (PROPERTIES_MAX).
    GetDeviceInfo {
        device_filter: Vec<String>,
        iterator: fidl::endpoints::ServerEnd<DeviceInfoIteratorMarker>,
        exact_match: bool,
        control_handle: DriverDevelopmentControlHandle,
    },
    /// Returns the list of composites in the system. This includes composites
    /// that are not yet assembled and added into the node topology.
    GetCompositeInfo {
        iterator: fidl::endpoints::ServerEnd<CompositeInfoIteratorMarker>,
        control_handle: DriverDevelopmentControlHandle,
    },
    /// (DFv2) Attempts to bind all unbound nodes in the topology.
    /// Returns new successful binds.
    BindAllUnboundNodes {
        responder: DriverDevelopmentBindAllUnboundNodesResponder,
    },
    IsDfv2 {
        responder: DriverDevelopmentIsDfv2Responder,
    },
    /// (DFv2) Adds test node under the root node.
    AddTestNode {
        args: TestNodeAddArgs,
        responder: DriverDevelopmentAddTestNodeResponder,
    },
    /// (DFv2) Removes the test node. The node is removed asynchronously and is
    /// not guaranteed to be removed by the time this returns.
    RemoveTestNode {
        name: String,
        responder: DriverDevelopmentRemoveTestNodeResponder,
    },
}

impl DriverDevelopmentRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_driver_info(
        self,
    ) -> Option<(
        Vec<String>,
        fidl::endpoints::ServerEnd<DriverInfoIteratorMarker>,
        DriverDevelopmentControlHandle,
    )> {
        if let DriverDevelopmentRequest::GetDriverInfo { driver_filter, iterator, control_handle } =
            self
        {
            Some((driver_filter, iterator, control_handle))
        } else {
            None
        }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_composite_node_specs(
        self,
    ) -> Option<(
        Option<String>,
        fidl::endpoints::ServerEnd<CompositeNodeSpecIteratorMarker>,
        DriverDevelopmentControlHandle,
    )> {
        if let DriverDevelopmentRequest::GetCompositeNodeSpecs {
            name_filter,
            iterator,
            control_handle,
        } = self
        {
            Some((name_filter, iterator, control_handle))
        } else {
            None
        }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_restart_driver_hosts(
        self,
    ) -> Option<(String, DriverDevelopmentRestartDriverHostsResponder)> {
        if let DriverDevelopmentRequest::RestartDriverHosts { driver_path, responder } = self {
            Some((driver_path, responder))
        } else {
            None
        }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_device_info(
        self,
    ) -> Option<(
        Vec<String>,
        fidl::endpoints::ServerEnd<DeviceInfoIteratorMarker>,
        bool,
        DriverDevelopmentControlHandle,
    )> {
        if let DriverDevelopmentRequest::GetDeviceInfo {
            device_filter,
            iterator,
            exact_match,
            control_handle,
        } = self
        {
            Some((device_filter, iterator, exact_match, control_handle))
        } else {
            None
        }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_composite_info(
        self,
    ) -> Option<(
        fidl::endpoints::ServerEnd<CompositeInfoIteratorMarker>,
        DriverDevelopmentControlHandle,
    )> {
        if let DriverDevelopmentRequest::GetCompositeInfo { iterator, control_handle } = self {
            Some((iterator, control_handle))
        } else {
            None
        }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_bind_all_unbound_nodes(
        self,
    ) -> Option<(DriverDevelopmentBindAllUnboundNodesResponder)> {
        if let DriverDevelopmentRequest::BindAllUnboundNodes { responder } = self {
            Some((responder))
        } else {
            None
        }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_is_dfv2(self) -> Option<(DriverDevelopmentIsDfv2Responder)> {
        if let DriverDevelopmentRequest::IsDfv2 { responder } = self {
            Some((responder))
        } else {
            None
        }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_add_test_node(
        self,
    ) -> Option<(TestNodeAddArgs, DriverDevelopmentAddTestNodeResponder)> {
        if let DriverDevelopmentRequest::AddTestNode { args, responder } = self {
            Some((args, responder))
        } else {
            None
        }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_remove_test_node(
        self,
    ) -> Option<(String, DriverDevelopmentRemoveTestNodeResponder)> {
        if let DriverDevelopmentRequest::RemoveTestNode { name, responder } = self {
            Some((name, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            DriverDevelopmentRequest::GetDriverInfo { .. } => "get_driver_info",
            DriverDevelopmentRequest::GetCompositeNodeSpecs { .. } => "get_composite_node_specs",
            DriverDevelopmentRequest::RestartDriverHosts { .. } => "restart_driver_hosts",
            DriverDevelopmentRequest::GetDeviceInfo { .. } => "get_device_info",
            DriverDevelopmentRequest::GetCompositeInfo { .. } => "get_composite_info",
            DriverDevelopmentRequest::BindAllUnboundNodes { .. } => "bind_all_unbound_nodes",
            DriverDevelopmentRequest::IsDfv2 { .. } => "is_dfv2",
            DriverDevelopmentRequest::AddTestNode { .. } => "add_test_node",
            DriverDevelopmentRequest::RemoveTestNode { .. } => "remove_test_node",
        }
    }
}

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

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

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

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

    fn send_raw(
        &self,
        mut result: &mut DriverDevelopmentRestartDriverHostsResult,
    ) -> Result<(), fidl::Error> {
        let msg = fidl::encoding::TransactionMessage {
            header: fidl::encoding::TransactionHeader::new(
                self.tx_id,
                self.ordinal,
                fidl::encoding::DynamicFlags::empty(),
            ),
            body: result.as_mut().map_err(|e| *e).map(|count| (*count,)),
        };

        fidl::encoding::with_tls_encode_buf(|bytes, handles| {
            fidl::duration_begin!("fidl", "encode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.driver.development/DriverDevelopmentRestartDriverHostsResponse");
            fidl::encoding::Encoder::encode::<
                fidl::encoding::TransactionMessageType<
                    fidl::encoding::ResultType<DriverDevelopmentRestartDriverHostsResponse, i32>,
                >,
            >(bytes, handles, 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 DriverDevelopmentBindAllUnboundNodesResponder {
    control_handle: std::mem::ManuallyDrop<DriverDevelopmentControlHandle>,
    tx_id: u32,
    ordinal: u64,
}

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

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

    fn send_raw(
        &self,
        mut result: &mut DriverDevelopmentBindAllUnboundNodesResult,
    ) -> Result<(), fidl::Error> {
        let msg = fidl::encoding::TransactionMessage {
            header: fidl::encoding::TransactionHeader::new(
                self.tx_id,
                self.ordinal,
                fidl::encoding::DynamicFlags::empty(),
            ),
            body: result
                .as_mut()
                .map_err(|e| *e)
                .map(|binding_result| (binding_result.as_slice(),)),
        };

        fidl::encoding::with_tls_encode_buf(|bytes, handles| {
            fidl::duration_begin!("fidl", "encode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.driver.development/DriverDevelopmentBindAllUnboundNodesResponse");
            fidl::encoding::Encoder::encode::<
                fidl::encoding::TransactionMessageType<
                    fidl::encoding::ResultType<DriverDevelopmentBindAllUnboundNodesResponse, i32>,
                >,
            >(bytes, handles, 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 DriverDevelopmentIsDfv2Responder {
    control_handle: std::mem::ManuallyDrop<DriverDevelopmentControlHandle>,
    tx_id: u32,
    ordinal: u64,
}

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

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

    fn send_raw(&self, mut response: bool) -> Result<(), fidl::Error> {
        let msg = fidl::encoding::TransactionMessage {
            header: fidl::encoding::TransactionHeader::new(
                self.tx_id,
                self.ordinal,
                fidl::encoding::DynamicFlags::empty(),
            ),
            body: (response,),
        };

        fidl::encoding::with_tls_encode_buf(|bytes, handles| {
            fidl::duration_begin!("fidl", "encode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.driver.development/DriverDevelopmentIsDfv2Response");
            fidl::encoding::Encoder::encode::<
                fidl::encoding::TransactionMessageType<DriverDevelopmentIsDfv2Response>,
            >(bytes, handles, 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 DriverDevelopmentAddTestNodeResponder {
    control_handle: std::mem::ManuallyDrop<DriverDevelopmentControlHandle>,
    tx_id: u32,
    ordinal: u64,
}

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

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

    fn send_raw(
        &self,
        mut result: &mut DriverDevelopmentAddTestNodeResult,
    ) -> Result<(), fidl::Error> {
        let msg = fidl::encoding::TransactionMessage {
            header: fidl::encoding::TransactionHeader::new(
                self.tx_id,
                self.ordinal,
                fidl::encoding::DynamicFlags::empty(),
            ),
            body: *result,
        };

        fidl::encoding::with_tls_encode_buf(|bytes, handles| {
            fidl::duration_begin!("fidl", "encode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.driver.development/DriverDevelopmentAddTestNodeResponse");
            fidl::encoding::Encoder::encode::<
                fidl::encoding::TransactionMessageType<
                    fidl::encoding::ResultType<
                        fidl::encoding::EmptyStruct,
                        fidl_fuchsia_driver_framework::NodeError,
                    >,
                >,
            >(bytes, handles, 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 DriverDevelopmentRemoveTestNodeResponder {
    control_handle: std::mem::ManuallyDrop<DriverDevelopmentControlHandle>,
    tx_id: u32,
    ordinal: u64,
}

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

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

    fn send_raw(
        &self,
        mut result: &mut DriverDevelopmentRemoveTestNodeResult,
    ) -> Result<(), fidl::Error> {
        let msg = fidl::encoding::TransactionMessage {
            header: fidl::encoding::TransactionHeader::new(
                self.tx_id,
                self.ordinal,
                fidl::encoding::DynamicFlags::empty(),
            ),
            body: *result,
        };

        fidl::encoding::with_tls_encode_buf(|bytes, handles| {
            fidl::duration_begin!("fidl", "encode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.driver.development/DriverDevelopmentRemoveTestNodeResponse");
            fidl::encoding::Encoder::encode::<
                fidl::encoding::TransactionMessageType<
                    fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                >,
            >(bytes, handles, 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 DriverIndexMarker;

impl fidl::endpoints::ProtocolMarker for DriverIndexMarker {
    type Proxy = DriverIndexProxy;
    type RequestStream = DriverIndexRequestStream;
    const DEBUG_NAME: &'static str = "fuchsia.driver.development.DriverIndex";
}
impl fidl::endpoints::DiscoverableProtocolMarker for DriverIndexMarker {}

pub trait DriverIndexProxyInterface: Send + Sync {
    fn r#get_driver_info(
        &self,
        driver_filter: &mut dyn ExactSizeIterator<Item = &str>,
        iterator: fidl::endpoints::ServerEnd<DriverInfoIteratorMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#get_composite_node_specs(
        &self,
        name_filter: Option<&str>,
        iterator: fidl::endpoints::ServerEnd<CompositeNodeSpecIteratorMarker>,
    ) -> Result<(), fidl::Error>;
}

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

#[cfg(target_os = "fuchsia")]
impl DriverIndexSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <DriverIndexMarker 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<DriverIndexEvent, fidl::Error> {
        DriverIndexEvent::decode(self.client.wait_for_event(deadline)?)
    }
    /// Returns a list of all drivers that are known to the system.
    /// If a |driver_filter| is provided, the returned list will be filtered to
    /// only include drivers specified in the filter.
    ///
    /// |iterator| is closed with following epitaphs on error:
    /// ZX_ERR_NOT_FOUND indicates that there is no driver matching the given path for at least
    /// one driver in |driver_filter|.
    /// ZX_ERR_BUFFER_TOO_SMALL indicates that the driver's bind program is longer than the
    /// maximum number of instructions (BIND_PROGRAM_INSTRUCTIONS_MAX).
    pub fn r#get_driver_info(
        &self,
        mut driver_filter: &mut dyn ExactSizeIterator<Item = &str>,
        mut iterator: fidl::endpoints::ServerEnd<DriverInfoIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DriverIndexGetDriverInfoRequest, false>(
            (fidl::encoding::Iterator(driver_filter), iterator),
            0x5f51f1ceaa350c28,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    /// Returns a list of all composite node specs that are known to the system.
    /// If a |name_filter| is provided, the returned list will only include 1 spec,
    /// the one with that exact name.
    ///
    /// |iterator| is closed with following epitaphs on error:
    /// ZX_ERR_NOT_FOUND indicates that there are no specs or if a |name_filter| is provided,
    /// that there are no specs with that name.
    pub fn r#get_composite_node_specs(
        &self,
        mut name_filter: Option<&str>,
        mut iterator: fidl::endpoints::ServerEnd<CompositeNodeSpecIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DriverIndexGetCompositeNodeSpecsRequest, false>(
            (name_filter, iterator),
            0x43104254014654e6,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::Proxy for DriverIndexProxy {
    type Protocol = DriverIndexMarker;

    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 DriverIndexProxy {
    /// Create a new Proxy for DriverIndex
    pub fn new(channel: fidl::AsyncChannel) -> Self {
        let protocol_name = <DriverIndexMarker 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 DriverIndex protocol
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> DriverIndexEventStream {
        DriverIndexEventStream { event_receiver: self.client.take_event_receiver() }
    }
    /// Returns a list of all drivers that are known to the system.
    /// If a |driver_filter| is provided, the returned list will be filtered to
    /// only include drivers specified in the filter.
    ///
    /// |iterator| is closed with following epitaphs on error:
    /// ZX_ERR_NOT_FOUND indicates that there is no driver matching the given path for at least
    /// one driver in |driver_filter|.
    /// ZX_ERR_BUFFER_TOO_SMALL indicates that the driver's bind program is longer than the
    /// maximum number of instructions (BIND_PROGRAM_INSTRUCTIONS_MAX).
    pub fn r#get_driver_info(
        &self,
        mut driver_filter: &mut dyn ExactSizeIterator<Item = &str>,
        mut iterator: fidl::endpoints::ServerEnd<DriverInfoIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        DriverIndexProxyInterface::r#get_driver_info(self, driver_filter, iterator)
    }
    /// Returns a list of all composite node specs that are known to the system.
    /// If a |name_filter| is provided, the returned list will only include 1 spec,
    /// the one with that exact name.
    ///
    /// |iterator| is closed with following epitaphs on error:
    /// ZX_ERR_NOT_FOUND indicates that there are no specs or if a |name_filter| is provided,
    /// that there are no specs with that name.
    pub fn r#get_composite_node_specs(
        &self,
        mut name_filter: Option<&str>,
        mut iterator: fidl::endpoints::ServerEnd<CompositeNodeSpecIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        DriverIndexProxyInterface::r#get_composite_node_specs(self, name_filter, iterator)
    }
}

impl DriverIndexProxyInterface for DriverIndexProxy {
    fn r#get_driver_info(
        &self,
        mut driver_filter: &mut dyn ExactSizeIterator<Item = &str>,
        mut iterator: fidl::endpoints::ServerEnd<DriverInfoIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DriverIndexGetDriverInfoRequest, false>(
            (fidl::encoding::Iterator(driver_filter), iterator),
            0x5f51f1ceaa350c28,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
    fn r#get_composite_node_specs(
        &self,
        mut name_filter: Option<&str>,
        mut iterator: fidl::endpoints::ServerEnd<CompositeNodeSpecIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DriverIndexGetCompositeNodeSpecsRequest, false>(
            (name_filter, iterator),
            0x43104254014654e6,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

impl futures::Stream for DriverIndexEventStream {
    type Item = Result<DriverIndexEvent, 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(DriverIndexEvent::decode(buf)))
    }
}

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

impl DriverIndexEvent {
    /// Decodes a message buffer as a [`DriverIndexEvent`]. Transaction
    /// ID in the message must be zero; this method does not check TXID.
    fn decode(mut buf: fidl::MessageBufEtc) -> Result<DriverIndexEvent, 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: <DriverIndexMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fidl::endpoints::RequestStream for DriverIndexRequestStream {
    type Protocol = DriverIndexMarker;
    type ControlHandle = DriverIndexControlHandle;

    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 {
        DriverIndexControlHandle { 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 DriverIndexRequestStream {
    type Item = Result<DriverIndexRequest, 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 DriverIndexRequestStream 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() {
                0x5f51f1ceaa350c28 => {
                    let mut req = fidl::new_empty!(DriverIndexGetDriverInfoRequest);
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.driver.development/DriverIndexGetDriverInfoRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    fidl::encoding::maybe_overflowing_decode::<DriverIndexGetDriverInfoRequest>(
                        &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 = DriverIndexControlHandle { inner: this.inner.clone() };

                    Ok(DriverIndexRequest::GetDriverInfo {
                        driver_filter: req.driver_filter,
                        iterator: req.iterator,

                        control_handle,
                    })
                }
                0x43104254014654e6 => {
                    let mut req = fidl::new_empty!(DriverIndexGetCompositeNodeSpecsRequest);
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.driver.development/DriverIndexGetCompositeNodeSpecsRequest");
                    fidl::trace_blob!("fidl:blob", "decode", bytes);
                    fidl::encoding::maybe_overflowing_decode::<
                        DriverIndexGetCompositeNodeSpecsRequest,
                    >(&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 = DriverIndexControlHandle { inner: this.inner.clone() };

                    Ok(DriverIndexRequest::GetCompositeNodeSpecs {
                        name_filter: req.name_filter,
                        iterator: req.iterator,

                        control_handle,
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal(),
                    protocol_name:
                        <DriverIndexMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
        })
    }
}
/// Interface for developing and debugging drivers.
/// This interface should only be used for development and disabled in release builds.
#[derive(Debug)]
pub enum DriverIndexRequest {
    /// Returns a list of all drivers that are known to the system.
    /// If a |driver_filter| is provided, the returned list will be filtered to
    /// only include drivers specified in the filter.
    ///
    /// |iterator| is closed with following epitaphs on error:
    /// ZX_ERR_NOT_FOUND indicates that there is no driver matching the given path for at least
    /// one driver in |driver_filter|.
    /// ZX_ERR_BUFFER_TOO_SMALL indicates that the driver's bind program is longer than the
    /// maximum number of instructions (BIND_PROGRAM_INSTRUCTIONS_MAX).
    GetDriverInfo {
        driver_filter: Vec<String>,
        iterator: fidl::endpoints::ServerEnd<DriverInfoIteratorMarker>,
        control_handle: DriverIndexControlHandle,
    },
    /// Returns a list of all composite node specs that are known to the system.
    /// If a |name_filter| is provided, the returned list will only include 1 spec,
    /// the one with that exact name.
    ///
    /// |iterator| is closed with following epitaphs on error:
    /// ZX_ERR_NOT_FOUND indicates that there are no specs or if a |name_filter| is provided,
    /// that there are no specs with that name.
    GetCompositeNodeSpecs {
        name_filter: Option<String>,
        iterator: fidl::endpoints::ServerEnd<CompositeNodeSpecIteratorMarker>,
        control_handle: DriverIndexControlHandle,
    },
}

impl DriverIndexRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_driver_info(
        self,
    ) -> Option<(
        Vec<String>,
        fidl::endpoints::ServerEnd<DriverInfoIteratorMarker>,
        DriverIndexControlHandle,
    )> {
        if let DriverIndexRequest::GetDriverInfo { driver_filter, iterator, control_handle } = self
        {
            Some((driver_filter, iterator, control_handle))
        } else {
            None
        }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_composite_node_specs(
        self,
    ) -> Option<(
        Option<String>,
        fidl::endpoints::ServerEnd<CompositeNodeSpecIteratorMarker>,
        DriverIndexControlHandle,
    )> {
        if let DriverIndexRequest::GetCompositeNodeSpecs { name_filter, iterator, control_handle } =
            self
        {
            Some((name_filter, iterator, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            DriverIndexRequest::GetDriverInfo { .. } => "get_driver_info",
            DriverIndexRequest::GetCompositeNodeSpecs { .. } => "get_composite_node_specs",
        }
    }
}

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

impl fidl::endpoints::ControlHandle for DriverIndexControlHandle {
    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 DriverIndexControlHandle {}

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

impl fidl::endpoints::ProtocolMarker for DriverInfoIteratorMarker {
    type Proxy = DriverInfoIteratorProxy;
    type RequestStream = DriverInfoIteratorRequestStream;
    const DEBUG_NAME: &'static str = "(anonymous) DriverInfoIterator";
}

pub trait DriverInfoIteratorProxyInterface: Send + Sync {
    type GetNextResponseFut: std::future::Future<Output = Result<Vec<DriverInfo>, fidl::Error>>
        + Send;
    fn r#get_next(&self) -> Self::GetNextResponseFut;
}

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

#[cfg(target_os = "fuchsia")]
impl DriverInfoIteratorSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <DriverInfoIteratorMarker 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<DriverInfoIteratorEvent, fidl::Error> {
        DriverInfoIteratorEvent::decode(self.client.wait_for_event(deadline)?)
    }
    /// Return 0 drivers when no more entries left.
    pub fn r#get_next(&self, ___deadline: zx::Time) -> Result<Vec<DriverInfo>, fidl::Error> {
        let _response = self.client.send_query::<
                fidl::encoding::EmptyPayload,
                DriverInfoIteratorGetNextResponse,false,true>(
                (),
                0x2c394711c6784952,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?
            ;
        Ok(_response.drivers)
    }
}

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

impl fidl::endpoints::Proxy for DriverInfoIteratorProxy {
    type Protocol = DriverInfoIteratorMarker;

    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 DriverInfoIteratorProxy {
    /// Create a new Proxy for DriverInfoIterator
    pub fn new(channel: fidl::AsyncChannel) -> Self {
        let protocol_name =
            <DriverInfoIteratorMarker 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 DriverInfoIterator protocol
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> DriverInfoIteratorEventStream {
        DriverInfoIteratorEventStream { event_receiver: self.client.take_event_receiver() }
    }
    /// Return 0 drivers when no more entries left.
    pub fn r#get_next(&self) -> fidl::client::QueryResponseFut<Vec<DriverInfo>> {
        DriverInfoIteratorProxyInterface::r#get_next(self)
    }
}

impl DriverInfoIteratorProxyInterface for DriverInfoIteratorProxy {
    type GetNextResponseFut = fidl::client::QueryResponseFut<Vec<DriverInfo>>;
    fn r#get_next(&self) -> Self::GetNextResponseFut {
        fn _decode(
            mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<DriverInfo>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DriverInfoIteratorGetNextResponse,
                true,
            >(_buf?)?;
            Ok(_response.drivers)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<DriverInfo>, false>(
            (),
            0x2c394711c6784952,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

impl futures::Stream for DriverInfoIteratorEventStream {
    type Item = Result<DriverInfoIteratorEvent, 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(DriverInfoIteratorEvent::decode(buf)))
    }
}

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

impl DriverInfoIteratorEvent {
    /// Decodes a message buffer as a [`DriverInfoIteratorEvent`]. Transaction
    /// ID in the message must be zero; this method does not check TXID.
    fn decode(mut buf: fidl::MessageBufEtc) -> Result<DriverInfoIteratorEvent, 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:
                    <DriverInfoIteratorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fidl::endpoints::RequestStream for DriverInfoIteratorRequestStream {
    type Protocol = DriverInfoIteratorMarker;
    type ControlHandle = DriverInfoIteratorControlHandle;

    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 {
        DriverInfoIteratorControlHandle { 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 DriverInfoIteratorRequestStream {
    type Item = Result<DriverInfoIteratorRequest, 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 DriverInfoIteratorRequestStream 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() {
                0x2c394711c6784952 => {
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
                    fidl::duration_begin!("fidl", "decode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.driver.development/DriverInfoIteratorGetNextRequest");
                    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::<fidl::encoding::EmptyPayload>(
                        &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 =
                        DriverInfoIteratorControlHandle { inner: this.inner.clone() };

                    Ok(DriverInfoIteratorRequest::GetNext {
                        responder: DriverInfoIteratorGetNextResponder {
                            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:
                        <DriverInfoIteratorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
        })
    }
}
#[derive(Debug)]
pub enum DriverInfoIteratorRequest {
    /// Return 0 drivers when no more entries left.
    GetNext { responder: DriverInfoIteratorGetNextResponder },
}

impl DriverInfoIteratorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_next(self) -> Option<(DriverInfoIteratorGetNextResponder)> {
        if let DriverInfoIteratorRequest::GetNext { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

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

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

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

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

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

    fn send_raw(
        &self,
        mut drivers: &mut dyn ExactSizeIterator<Item = DriverInfo>,
    ) -> Result<(), fidl::Error> {
        let msg = fidl::encoding::TransactionMessage {
            header: fidl::encoding::TransactionHeader::new(
                self.tx_id,
                self.ordinal,
                fidl::encoding::DynamicFlags::empty(),
            ),
            body: (fidl::encoding::Iterator(drivers),),
        };

        fidl::encoding::with_tls_encode_buf(|bytes, handles| {
            fidl::duration_begin!("fidl", "encode", "bindings" => _FIDL_TRACE_BINDINGS_RUST, "name" => "fuchsia.driver.development/DriverInfoIteratorGetNextResponse");
            fidl::encoding::Encoder::encode::<
                fidl::encoding::TransactionMessageType<DriverInfoIteratorGetNextResponse>,
            >(bytes, handles, 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)
        })
    }
}