fidl_fuchsia_bluetooth_sys/

fidl_fuchsia_bluetooth_sys.rs

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

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

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct AccessMakeDiscoverableRequest {
    pub token: fidl::endpoints::ServerEnd<ProcedureTokenMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct AccessSetPairingDelegateRequest {
    pub input: InputCapability,
    pub output: OutputCapability,
    pub delegate: fidl::endpoints::ClientEnd<PairingDelegateMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct AccessStartDiscoveryRequest {
    pub token: fidl::endpoints::ServerEnd<ProcedureTokenMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct PairingSetDelegateRequest {
    pub input: InputCapability,
    pub output: OutputCapability,
    pub delegate: fidl::endpoints::ClientEnd<PairingDelegate2Marker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct PairingSetPairingDelegateRequest {
    pub input: InputCapability,
    pub output: OutputCapability,
    pub delegate: fidl::endpoints::ClientEnd<PairingDelegateMarker>,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct AccessSetConnectionPolicyRequest {
    /// Suppress all new connections over the BR/EDR transport. The active host will disable
    /// page scan while the `ProcedureToken` is held open.
    /// NOTE: The system will remain non-connectable until all [`fuchsia.bluetooth.sys/Access`]
    /// clients drop their tokens.
    pub suppress_bredr_connections: Option<fidl::endpoints::ServerEnd<ProcedureTokenMarker>>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct PairingDelegate2StartRequestRequest {
    /// Peer making the request.
    pub peer: Option<Peer>,
    /// Properties of the pairing.
    pub info: Option<PairingProperties>,
    /// Protocol used to complete the pairing process.
    pub request: Option<fidl::endpoints::ClientEnd<PairingRequestMarker>>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

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

impl fidl::endpoints::ProtocolMarker for AccessMarker {
    type Proxy = AccessProxy;
    type RequestStream = AccessRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = AccessSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.bluetooth.sys.Access";
}
impl fidl::endpoints::DiscoverableProtocolMarker for AccessMarker {}
pub type AccessMakeDiscoverableResult = Result<(), Error>;
pub type AccessSetConnectionPolicyResult = Result<(), Error>;
pub type AccessStartDiscoveryResult = Result<(), Error>;
pub type AccessConnectResult = Result<(), Error>;
pub type AccessDisconnectResult = Result<(), Error>;
pub type AccessPairResult = Result<(), Error>;
pub type AccessForgetResult = Result<(), Error>;

pub trait AccessProxyInterface: Send + Sync {
    fn r#set_pairing_delegate(
        &self,
        input: InputCapability,
        output: OutputCapability,
        delegate: fidl::endpoints::ClientEnd<PairingDelegateMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#set_local_name(&self, name: &str) -> Result<(), fidl::Error>;
    fn r#set_device_class(
        &self,
        device_class: &fidl_fuchsia_bluetooth::DeviceClass,
    ) -> Result<(), fidl::Error>;
    type MakeDiscoverableResponseFut: std::future::Future<Output = Result<AccessMakeDiscoverableResult, fidl::Error>>
        + Send;
    fn r#make_discoverable(
        &self,
        token: fidl::endpoints::ServerEnd<ProcedureTokenMarker>,
    ) -> Self::MakeDiscoverableResponseFut;
    type SetConnectionPolicyResponseFut: std::future::Future<Output = Result<AccessSetConnectionPolicyResult, fidl::Error>>
        + Send;
    fn r#set_connection_policy(
        &self,
        payload: AccessSetConnectionPolicyRequest,
    ) -> Self::SetConnectionPolicyResponseFut;
    type StartDiscoveryResponseFut: std::future::Future<Output = Result<AccessStartDiscoveryResult, fidl::Error>>
        + Send;
    fn r#start_discovery(
        &self,
        token: fidl::endpoints::ServerEnd<ProcedureTokenMarker>,
    ) -> Self::StartDiscoveryResponseFut;
    type WatchPeersResponseFut: std::future::Future<
            Output = Result<(Vec<Peer>, Vec<fidl_fuchsia_bluetooth::PeerId>), fidl::Error>,
        > + Send;
    fn r#watch_peers(&self) -> Self::WatchPeersResponseFut;
    type ConnectResponseFut: std::future::Future<Output = Result<AccessConnectResult, fidl::Error>>
        + Send;
    fn r#connect(&self, id: &fidl_fuchsia_bluetooth::PeerId) -> Self::ConnectResponseFut;
    type DisconnectResponseFut: std::future::Future<Output = Result<AccessDisconnectResult, fidl::Error>>
        + Send;
    fn r#disconnect(&self, id: &fidl_fuchsia_bluetooth::PeerId) -> Self::DisconnectResponseFut;
    type PairResponseFut: std::future::Future<Output = Result<AccessPairResult, fidl::Error>> + Send;
    fn r#pair(
        &self,
        id: &fidl_fuchsia_bluetooth::PeerId,
        options: &PairingOptions,
    ) -> Self::PairResponseFut;
    type ForgetResponseFut: std::future::Future<Output = Result<AccessForgetResult, fidl::Error>>
        + Send;
    fn r#forget(&self, id: &fidl_fuchsia_bluetooth::PeerId) -> Self::ForgetResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct AccessSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for AccessSynchronousProxy {
    type Proxy = AccessProxy;
    type Protocol = AccessMarker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl AccessSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

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

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

    /// Assign a PairingDelegate to respond to drive pairing procedures. The delegate will be
    /// configured to use the provided I/O capabilities to determine the pairing method.
    ///
    /// Only one PairingDelegate can be registered at a time. Closing a PairingDelegate aborts all
    /// on-going pairing procedures associated with a delegate and closes the PairingDelegate
    /// previously assigned for this Access instance.
    ///
    /// + request `input` Bluetooth input capability
    /// + request `output` Bluetooth output capability
    /// + request `delegate` The client end of a PairingDelegate channel.
    /// # Deprecation - This method is folded into the fuchsia.bluetooth.sys/Pairing protocol. See
    ///   https://fxbug.dev/42180744 for more details on the migration.
    pub fn r#set_pairing_delegate(
        &self,
        mut input: InputCapability,
        mut output: OutputCapability,
        mut delegate: fidl::endpoints::ClientEnd<PairingDelegateMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AccessSetPairingDelegateRequest>(
            (input, output, delegate),
            0x4af398e1f4cdb40b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Assign a local name for the Bluetooth system. This name will be visible to nearby peers
    /// when the system is in discoverable mode and during name discovery procedures.
    ///
    /// + request `name` The complete local name to assign to the system.
    pub fn r#set_local_name(&self, mut name: &str) -> Result<(), fidl::Error> {
        self.client.send::<AccessSetLocalNameRequest>(
            (name,),
            0x7d12cd2d902206eb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Set the local device class that will be visible to nearby peers when the system is in
    /// discoverable mode.
    ///
    /// + request `device_class` The device class to assign to the system.
    pub fn r#set_device_class(
        &self,
        mut device_class: &fidl_fuchsia_bluetooth::DeviceClass,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AccessSetDeviceClassRequest>(
            (device_class,),
            0x58dd8f65f589035d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Put the system into the "General Discoverable" mode on the BR/EDR transport. The active
    /// host will respond to general inquiry (by regularly entering the inquiry scan mode).
    ///
    /// + request `token` [`fuchsia.bluetooth.sys/ProcedureToken`] that will remain valid while a
    ///   discoverable mode session is active. NOTE: The system may remain discoverable until all
    ///   [`fuchsia.bluetooth.sys/Access`] clients drop their tokens.
    /// * error Reports Error.FAILED if inquiry mode cannot be entered.
    pub fn r#make_discoverable(
        &self,
        mut token: fidl::endpoints::ServerEnd<ProcedureTokenMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<AccessMakeDiscoverableResult, fidl::Error> {
        let _response = self.client.send_query::<
            AccessMakeDiscoverableRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
            AccessMarker,
        >(
            (token,),
            0x747cadf609c96fb1,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Set the BR/EDR and LE connection policy for the active host.
    ///
    /// * error Reports Error.FAILED if the requested connection policy couldn't be applied.
    pub fn r#set_connection_policy(
        &self,
        mut payload: AccessSetConnectionPolicyRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<AccessSetConnectionPolicyResult, fidl::Error> {
        let _response = self.client.send_query::<
            AccessSetConnectionPolicyRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
            AccessMarker,
        >(
            &mut payload,
            0x8e8c7354932fb5a,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Start a general discovery procedure. All general discoverable BR/EDR, LE,
    /// and BR/EDR/LE devices will appear in the peer list, which can be observed by calling
    /// [`fuchsia.bluetooth.sys/Access.WatchPeers`].
    ///
    /// + request `token` [`fuchsia.bluetooth.sys/ProcedureToken`] that will remain valid while
    ///   discovery is in progress. NOTE: The radio will continue performing discovery until all
    ///   [`fuchsia.bluetooth.sys/Access`] drop their tokens.
    /// * error Reports Error.FAILED if discovery on either transport cannot be initiated.
    pub fn r#start_discovery(
        &self,
        mut token: fidl::endpoints::ServerEnd<ProcedureTokenMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<AccessStartDiscoveryResult, fidl::Error> {
        let _response = self.client.send_query::<
            AccessStartDiscoveryRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
            AccessMarker,
        >(
            (token,),
            0x6907100d9b99439,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Returns a list of all peers (connectable Bluetooth devices) known to the system. The first
    /// call results in a snapshot of all known peers to be sent immediately in the `updated` return
    /// paremeter. Subsequent calls receive a response only when one or more entries have been
    /// added, modified, or removed from the entries reported since the most recent call.
    ///
    /// - response `updated` Peers that were added or updated since the last call to WatchPeers().
    /// - response `removed` Ids of peers that were removed since the last call to WatchPeers().
    pub fn r#watch_peers(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(Vec<Peer>, Vec<fidl_fuchsia_bluetooth::PeerId>), fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, AccessWatchPeersResponse, AccessMarker>(
                (),
                0x1921fe1ed8e6eb7c,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok((_response.updated, _response.removed))
    }

    /// Initiate a connection to the peer with the given `id`. This method connects both BR/EDR and
    /// LE transports depending on the technologies that the peer is known to support.
    ///
    /// + request `id` The id of the peer to connect.
    /// * error Reports `Error.FAILED` if a connection to the peer cannot be initiated.
    /// * error Reports `Error.PEER_NOT_FOUND` if `id` is not recognized.
    pub fn r#connect(
        &self,
        mut id: &fidl_fuchsia_bluetooth::PeerId,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<AccessConnectResult, fidl::Error> {
        let _response = self.client.send_query::<AccessConnectRequest, fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            Error,
        >, AccessMarker>(
            (id,),
            0x1734199789fe7667,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Disconnect all logical links to the peer with the given `id`. This includes LE and
    /// BR/EDR links that have been initiated using all Access and fuchsia.bluetooth.le protocol
    /// instances.
    ///
    /// + request `id` The id of the peer to disconnect.
    /// * error Reports `Error.PEER_NOT_FOUND` if `id` is not recognized.
    pub fn r#disconnect(
        &self,
        mut id: &fidl_fuchsia_bluetooth::PeerId,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<AccessDisconnectResult, fidl::Error> {
        let _response = self.client.send_query::<
            AccessDisconnectRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
            AccessMarker,
        >(
            (id,),
            0x3a4e06d0c6185a5,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Initiate a pairing to the remote `id` with the given `options`.
    /// This call completes only once the pairing procedure has completed or aborted.
    /// Returns an error if no connected peer with `id` is found or the pairing procedure fails.
    /// If the named peer is already paired, this returns immediately with a success value - unless
    /// the pairing is over LE and the PairingOptions.le_security_level is more secure than the
    /// current security level, in which case we will attempt to raise security to the requested
    /// level.
    ///
    /// Pairing will take place over whichever transport is indicated by `options.transport`. If
    /// that transport isn't currently connected, the pairing will fail with `Error.PEER_NOT_FOUND`.
    /// Currently, if DUAL_MODE is requested, we will attempt to pair over the LE transport.
    ///
    /// + request `id` The id of the peer to initiate pairing with
    /// + request `options` The configuration options to use for this pairing request
    /// * error Reports `Error.PEER_NOT_FOUND` if `id` is not recognized, or the peer is not
    ///   connected on the requested transport.
    /// * error Reports `Error.INVALID_ARGUMENTS` if ill-formed options are passed
    /// * error Reports `Error.FAILED` if an error occurs during pairing
    pub fn r#pair(
        &self,
        mut id: &fidl_fuchsia_bluetooth::PeerId,
        mut options: &PairingOptions,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<AccessPairResult, fidl::Error> {
        let _response = self.client.send_query::<AccessPairRequest, fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            Error,
        >, AccessMarker>(
            (id, options),
            0x1d08ea19db327779,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Removes all bonding information and disconnects any existing links with the peer with the
    /// given `id`.
    ///
    /// + request `id` The id of the peer to forget.
    /// * error Reports `Error.PEER_NOT_FOUND` if `id` is not recognized.
    pub fn r#forget(
        &self,
        mut id: &fidl_fuchsia_bluetooth::PeerId,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<AccessForgetResult, fidl::Error> {
        let _response = self.client.send_query::<AccessForgetRequest, fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            Error,
        >, AccessMarker>(
            (id,),
            0x1fd8e27202854c0,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for AccessProxy {
    type Protocol = AccessMarker;

    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 AccessProxy {
    /// Create a new Proxy for fuchsia.bluetooth.sys/Access.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <AccessMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

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

    /// Assign a PairingDelegate to respond to drive pairing procedures. The delegate will be
    /// configured to use the provided I/O capabilities to determine the pairing method.
    ///
    /// Only one PairingDelegate can be registered at a time. Closing a PairingDelegate aborts all
    /// on-going pairing procedures associated with a delegate and closes the PairingDelegate
    /// previously assigned for this Access instance.
    ///
    /// + request `input` Bluetooth input capability
    /// + request `output` Bluetooth output capability
    /// + request `delegate` The client end of a PairingDelegate channel.
    /// # Deprecation - This method is folded into the fuchsia.bluetooth.sys/Pairing protocol. See
    ///   https://fxbug.dev/42180744 for more details on the migration.
    pub fn r#set_pairing_delegate(
        &self,
        mut input: InputCapability,
        mut output: OutputCapability,
        mut delegate: fidl::endpoints::ClientEnd<PairingDelegateMarker>,
    ) -> Result<(), fidl::Error> {
        AccessProxyInterface::r#set_pairing_delegate(self, input, output, delegate)
    }

    /// Assign a local name for the Bluetooth system. This name will be visible to nearby peers
    /// when the system is in discoverable mode and during name discovery procedures.
    ///
    /// + request `name` The complete local name to assign to the system.
    pub fn r#set_local_name(&self, mut name: &str) -> Result<(), fidl::Error> {
        AccessProxyInterface::r#set_local_name(self, name)
    }

    /// Set the local device class that will be visible to nearby peers when the system is in
    /// discoverable mode.
    ///
    /// + request `device_class` The device class to assign to the system.
    pub fn r#set_device_class(
        &self,
        mut device_class: &fidl_fuchsia_bluetooth::DeviceClass,
    ) -> Result<(), fidl::Error> {
        AccessProxyInterface::r#set_device_class(self, device_class)
    }

    /// Put the system into the "General Discoverable" mode on the BR/EDR transport. The active
    /// host will respond to general inquiry (by regularly entering the inquiry scan mode).
    ///
    /// + request `token` [`fuchsia.bluetooth.sys/ProcedureToken`] that will remain valid while a
    ///   discoverable mode session is active. NOTE: The system may remain discoverable until all
    ///   [`fuchsia.bluetooth.sys/Access`] clients drop their tokens.
    /// * error Reports Error.FAILED if inquiry mode cannot be entered.
    pub fn r#make_discoverable(
        &self,
        mut token: fidl::endpoints::ServerEnd<ProcedureTokenMarker>,
    ) -> fidl::client::QueryResponseFut<
        AccessMakeDiscoverableResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        AccessProxyInterface::r#make_discoverable(self, token)
    }

    /// Set the BR/EDR and LE connection policy for the active host.
    ///
    /// * error Reports Error.FAILED if the requested connection policy couldn't be applied.
    pub fn r#set_connection_policy(
        &self,
        mut payload: AccessSetConnectionPolicyRequest,
    ) -> fidl::client::QueryResponseFut<
        AccessSetConnectionPolicyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        AccessProxyInterface::r#set_connection_policy(self, payload)
    }

    /// Start a general discovery procedure. All general discoverable BR/EDR, LE,
    /// and BR/EDR/LE devices will appear in the peer list, which can be observed by calling
    /// [`fuchsia.bluetooth.sys/Access.WatchPeers`].
    ///
    /// + request `token` [`fuchsia.bluetooth.sys/ProcedureToken`] that will remain valid while
    ///   discovery is in progress. NOTE: The radio will continue performing discovery until all
    ///   [`fuchsia.bluetooth.sys/Access`] drop their tokens.
    /// * error Reports Error.FAILED if discovery on either transport cannot be initiated.
    pub fn r#start_discovery(
        &self,
        mut token: fidl::endpoints::ServerEnd<ProcedureTokenMarker>,
    ) -> fidl::client::QueryResponseFut<
        AccessStartDiscoveryResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        AccessProxyInterface::r#start_discovery(self, token)
    }

    /// Returns a list of all peers (connectable Bluetooth devices) known to the system. The first
    /// call results in a snapshot of all known peers to be sent immediately in the `updated` return
    /// paremeter. Subsequent calls receive a response only when one or more entries have been
    /// added, modified, or removed from the entries reported since the most recent call.
    ///
    /// - response `updated` Peers that were added or updated since the last call to WatchPeers().
    /// - response `removed` Ids of peers that were removed since the last call to WatchPeers().
    pub fn r#watch_peers(
        &self,
    ) -> fidl::client::QueryResponseFut<
        (Vec<Peer>, Vec<fidl_fuchsia_bluetooth::PeerId>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        AccessProxyInterface::r#watch_peers(self)
    }

    /// Initiate a connection to the peer with the given `id`. This method connects both BR/EDR and
    /// LE transports depending on the technologies that the peer is known to support.
    ///
    /// + request `id` The id of the peer to connect.
    /// * error Reports `Error.FAILED` if a connection to the peer cannot be initiated.
    /// * error Reports `Error.PEER_NOT_FOUND` if `id` is not recognized.
    pub fn r#connect(
        &self,
        mut id: &fidl_fuchsia_bluetooth::PeerId,
    ) -> fidl::client::QueryResponseFut<
        AccessConnectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        AccessProxyInterface::r#connect(self, id)
    }

    /// Disconnect all logical links to the peer with the given `id`. This includes LE and
    /// BR/EDR links that have been initiated using all Access and fuchsia.bluetooth.le protocol
    /// instances.
    ///
    /// + request `id` The id of the peer to disconnect.
    /// * error Reports `Error.PEER_NOT_FOUND` if `id` is not recognized.
    pub fn r#disconnect(
        &self,
        mut id: &fidl_fuchsia_bluetooth::PeerId,
    ) -> fidl::client::QueryResponseFut<
        AccessDisconnectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        AccessProxyInterface::r#disconnect(self, id)
    }

    /// Initiate a pairing to the remote `id` with the given `options`.
    /// This call completes only once the pairing procedure has completed or aborted.
    /// Returns an error if no connected peer with `id` is found or the pairing procedure fails.
    /// If the named peer is already paired, this returns immediately with a success value - unless
    /// the pairing is over LE and the PairingOptions.le_security_level is more secure than the
    /// current security level, in which case we will attempt to raise security to the requested
    /// level.
    ///
    /// Pairing will take place over whichever transport is indicated by `options.transport`. If
    /// that transport isn't currently connected, the pairing will fail with `Error.PEER_NOT_FOUND`.
    /// Currently, if DUAL_MODE is requested, we will attempt to pair over the LE transport.
    ///
    /// + request `id` The id of the peer to initiate pairing with
    /// + request `options` The configuration options to use for this pairing request
    /// * error Reports `Error.PEER_NOT_FOUND` if `id` is not recognized, or the peer is not
    ///   connected on the requested transport.
    /// * error Reports `Error.INVALID_ARGUMENTS` if ill-formed options are passed
    /// * error Reports `Error.FAILED` if an error occurs during pairing
    pub fn r#pair(
        &self,
        mut id: &fidl_fuchsia_bluetooth::PeerId,
        mut options: &PairingOptions,
    ) -> fidl::client::QueryResponseFut<
        AccessPairResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        AccessProxyInterface::r#pair(self, id, options)
    }

    /// Removes all bonding information and disconnects any existing links with the peer with the
    /// given `id`.
    ///
    /// + request `id` The id of the peer to forget.
    /// * error Reports `Error.PEER_NOT_FOUND` if `id` is not recognized.
    pub fn r#forget(
        &self,
        mut id: &fidl_fuchsia_bluetooth::PeerId,
    ) -> fidl::client::QueryResponseFut<
        AccessForgetResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        AccessProxyInterface::r#forget(self, id)
    }
}

impl AccessProxyInterface for AccessProxy {
    fn r#set_pairing_delegate(
        &self,
        mut input: InputCapability,
        mut output: OutputCapability,
        mut delegate: fidl::endpoints::ClientEnd<PairingDelegateMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AccessSetPairingDelegateRequest>(
            (input, output, delegate),
            0x4af398e1f4cdb40b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_local_name(&self, mut name: &str) -> Result<(), fidl::Error> {
        self.client.send::<AccessSetLocalNameRequest>(
            (name,),
            0x7d12cd2d902206eb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_device_class(
        &self,
        mut device_class: &fidl_fuchsia_bluetooth::DeviceClass,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AccessSetDeviceClassRequest>(
            (device_class,),
            0x58dd8f65f589035d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type MakeDiscoverableResponseFut = fidl::client::QueryResponseFut<
        AccessMakeDiscoverableResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#make_discoverable(
        &self,
        mut token: fidl::endpoints::ServerEnd<ProcedureTokenMarker>,
    ) -> Self::MakeDiscoverableResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<AccessMakeDiscoverableResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x747cadf609c96fb1,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<AccessMakeDiscoverableRequest, AccessMakeDiscoverableResult>(
                (token,),
                0x747cadf609c96fb1,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetConnectionPolicyResponseFut = fidl::client::QueryResponseFut<
        AccessSetConnectionPolicyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_connection_policy(
        &self,
        mut payload: AccessSetConnectionPolicyRequest,
    ) -> Self::SetConnectionPolicyResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<AccessSetConnectionPolicyResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x8e8c7354932fb5a,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            AccessSetConnectionPolicyRequest,
            AccessSetConnectionPolicyResult,
        >(
            &mut payload,
            0x8e8c7354932fb5a,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type StartDiscoveryResponseFut = fidl::client::QueryResponseFut<
        AccessStartDiscoveryResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#start_discovery(
        &self,
        mut token: fidl::endpoints::ServerEnd<ProcedureTokenMarker>,
    ) -> Self::StartDiscoveryResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<AccessStartDiscoveryResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6907100d9b99439,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<AccessStartDiscoveryRequest, AccessStartDiscoveryResult>(
                (token,),
                0x6907100d9b99439,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type WatchPeersResponseFut = fidl::client::QueryResponseFut<
        (Vec<Peer>, Vec<fidl_fuchsia_bluetooth::PeerId>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#watch_peers(&self) -> Self::WatchPeersResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(Vec<Peer>, Vec<fidl_fuchsia_bluetooth::PeerId>), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                AccessWatchPeersResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1921fe1ed8e6eb7c,
            >(_buf?)?;
            Ok((_response.updated, _response.removed))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            (Vec<Peer>, Vec<fidl_fuchsia_bluetooth::PeerId>),
        >(
            (),
            0x1921fe1ed8e6eb7c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ConnectResponseFut = fidl::client::QueryResponseFut<
        AccessConnectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#connect(&self, mut id: &fidl_fuchsia_bluetooth::PeerId) -> Self::ConnectResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<AccessConnectResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1734199789fe7667,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<AccessConnectRequest, AccessConnectResult>(
            (id,),
            0x1734199789fe7667,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type DisconnectResponseFut = fidl::client::QueryResponseFut<
        AccessDisconnectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#disconnect(&self, mut id: &fidl_fuchsia_bluetooth::PeerId) -> Self::DisconnectResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<AccessDisconnectResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3a4e06d0c6185a5,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<AccessDisconnectRequest, AccessDisconnectResult>(
            (id,),
            0x3a4e06d0c6185a5,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type PairResponseFut = fidl::client::QueryResponseFut<
        AccessPairResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#pair(
        &self,
        mut id: &fidl_fuchsia_bluetooth::PeerId,
        mut options: &PairingOptions,
    ) -> Self::PairResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<AccessPairResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1d08ea19db327779,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<AccessPairRequest, AccessPairResult>(
            (id, options),
            0x1d08ea19db327779,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ForgetResponseFut = fidl::client::QueryResponseFut<
        AccessForgetResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#forget(&self, mut id: &fidl_fuchsia_bluetooth::PeerId) -> Self::ForgetResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<AccessForgetResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1fd8e27202854c0,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<AccessForgetRequest, AccessForgetResult>(
            (id,),
            0x1fd8e27202854c0,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.bluetooth.sys/Access.
pub struct AccessRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for AccessRequestStream {
    type Protocol = AccessMarker;
    type ControlHandle = AccessControlHandle;

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x4af398e1f4cdb40b => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            AccessSetPairingDelegateRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AccessSetPairingDelegateRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = AccessControlHandle { inner: this.inner.clone() };
                        Ok(AccessRequest::SetPairingDelegate {
                            input: req.input,
                            output: req.output,
                            delegate: req.delegate,

                            control_handle,
                        })
                    }
                    0x7d12cd2d902206eb => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            AccessSetLocalNameRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AccessSetLocalNameRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = AccessControlHandle { inner: this.inner.clone() };
                        Ok(AccessRequest::SetLocalName { name: req.name, control_handle })
                    }
                    0x58dd8f65f589035d => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            AccessSetDeviceClassRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AccessSetDeviceClassRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = AccessControlHandle { inner: this.inner.clone() };
                        Ok(AccessRequest::SetDeviceClass {
                            device_class: req.device_class,

                            control_handle,
                        })
                    }
                    0x747cadf609c96fb1 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            AccessMakeDiscoverableRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AccessMakeDiscoverableRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = AccessControlHandle { inner: this.inner.clone() };
                        Ok(AccessRequest::MakeDiscoverable {
                            token: req.token,

                            responder: AccessMakeDiscoverableResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x8e8c7354932fb5a => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            AccessSetConnectionPolicyRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AccessSetConnectionPolicyRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = AccessControlHandle { inner: this.inner.clone() };
                        Ok(AccessRequest::SetConnectionPolicy {
                            payload: req,
                            responder: AccessSetConnectionPolicyResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6907100d9b99439 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            AccessStartDiscoveryRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AccessStartDiscoveryRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = AccessControlHandle { inner: this.inner.clone() };
                        Ok(AccessRequest::StartDiscovery {
                            token: req.token,

                            responder: AccessStartDiscoveryResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1921fe1ed8e6eb7c => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = AccessControlHandle { inner: this.inner.clone() };
                        Ok(AccessRequest::WatchPeers {
                            responder: AccessWatchPeersResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1734199789fe7667 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            AccessConnectRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AccessConnectRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = AccessControlHandle { inner: this.inner.clone() };
                        Ok(AccessRequest::Connect {
                            id: req.id,

                            responder: AccessConnectResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3a4e06d0c6185a5 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            AccessDisconnectRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AccessDisconnectRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = AccessControlHandle { inner: this.inner.clone() };
                        Ok(AccessRequest::Disconnect {
                            id: req.id,

                            responder: AccessDisconnectResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1d08ea19db327779 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            AccessPairRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AccessPairRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = AccessControlHandle { inner: this.inner.clone() };
                        Ok(AccessRequest::Pair {
                            id: req.id,
                            options: req.options,

                            responder: AccessPairResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1fd8e27202854c0 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            AccessForgetRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AccessForgetRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = AccessControlHandle { inner: this.inner.clone() };
                        Ok(AccessRequest::Forget {
                            id: req.id,

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

/// Protocol that abstracts the operational modes and procedures defined in the Bluetooth Generic
/// Access Profile (see Core Specification v5.1, Vol 3, Part C).
///
/// The procedures under this protocol apply to the system as a whole. The Bluetooth controller that
/// plays an active role in these procedures can be managed using the HostWatcher protocol.
///
/// The procedures initiated by an Access protocol instance are terminated when the underlying
/// channel is closed.
#[derive(Debug)]
pub enum AccessRequest {
    /// Assign a PairingDelegate to respond to drive pairing procedures. The delegate will be
    /// configured to use the provided I/O capabilities to determine the pairing method.
    ///
    /// Only one PairingDelegate can be registered at a time. Closing a PairingDelegate aborts all
    /// on-going pairing procedures associated with a delegate and closes the PairingDelegate
    /// previously assigned for this Access instance.
    ///
    /// + request `input` Bluetooth input capability
    /// + request `output` Bluetooth output capability
    /// + request `delegate` The client end of a PairingDelegate channel.
    /// # Deprecation - This method is folded into the fuchsia.bluetooth.sys/Pairing protocol. See
    ///   https://fxbug.dev/42180744 for more details on the migration.
    SetPairingDelegate {
        input: InputCapability,
        output: OutputCapability,
        delegate: fidl::endpoints::ClientEnd<PairingDelegateMarker>,
        control_handle: AccessControlHandle,
    },
    /// Assign a local name for the Bluetooth system. This name will be visible to nearby peers
    /// when the system is in discoverable mode and during name discovery procedures.
    ///
    /// + request `name` The complete local name to assign to the system.
    SetLocalName { name: String, control_handle: AccessControlHandle },
    /// Set the local device class that will be visible to nearby peers when the system is in
    /// discoverable mode.
    ///
    /// + request `device_class` The device class to assign to the system.
    SetDeviceClass {
        device_class: fidl_fuchsia_bluetooth::DeviceClass,
        control_handle: AccessControlHandle,
    },
    /// Put the system into the "General Discoverable" mode on the BR/EDR transport. The active
    /// host will respond to general inquiry (by regularly entering the inquiry scan mode).
    ///
    /// + request `token` [`fuchsia.bluetooth.sys/ProcedureToken`] that will remain valid while a
    ///   discoverable mode session is active. NOTE: The system may remain discoverable until all
    ///   [`fuchsia.bluetooth.sys/Access`] clients drop their tokens.
    /// * error Reports Error.FAILED if inquiry mode cannot be entered.
    MakeDiscoverable {
        token: fidl::endpoints::ServerEnd<ProcedureTokenMarker>,
        responder: AccessMakeDiscoverableResponder,
    },
    /// Set the BR/EDR and LE connection policy for the active host.
    ///
    /// * error Reports Error.FAILED if the requested connection policy couldn't be applied.
    SetConnectionPolicy {
        payload: AccessSetConnectionPolicyRequest,
        responder: AccessSetConnectionPolicyResponder,
    },
    /// Start a general discovery procedure. All general discoverable BR/EDR, LE,
    /// and BR/EDR/LE devices will appear in the peer list, which can be observed by calling
    /// [`fuchsia.bluetooth.sys/Access.WatchPeers`].
    ///
    /// + request `token` [`fuchsia.bluetooth.sys/ProcedureToken`] that will remain valid while
    ///   discovery is in progress. NOTE: The radio will continue performing discovery until all
    ///   [`fuchsia.bluetooth.sys/Access`] drop their tokens.
    /// * error Reports Error.FAILED if discovery on either transport cannot be initiated.
    StartDiscovery {
        token: fidl::endpoints::ServerEnd<ProcedureTokenMarker>,
        responder: AccessStartDiscoveryResponder,
    },
    /// Returns a list of all peers (connectable Bluetooth devices) known to the system. The first
    /// call results in a snapshot of all known peers to be sent immediately in the `updated` return
    /// paremeter. Subsequent calls receive a response only when one or more entries have been
    /// added, modified, or removed from the entries reported since the most recent call.
    ///
    /// - response `updated` Peers that were added or updated since the last call to WatchPeers().
    /// - response `removed` Ids of peers that were removed since the last call to WatchPeers().
    WatchPeers { responder: AccessWatchPeersResponder },
    /// Initiate a connection to the peer with the given `id`. This method connects both BR/EDR and
    /// LE transports depending on the technologies that the peer is known to support.
    ///
    /// + request `id` The id of the peer to connect.
    /// * error Reports `Error.FAILED` if a connection to the peer cannot be initiated.
    /// * error Reports `Error.PEER_NOT_FOUND` if `id` is not recognized.
    Connect { id: fidl_fuchsia_bluetooth::PeerId, responder: AccessConnectResponder },
    /// Disconnect all logical links to the peer with the given `id`. This includes LE and
    /// BR/EDR links that have been initiated using all Access and fuchsia.bluetooth.le protocol
    /// instances.
    ///
    /// + request `id` The id of the peer to disconnect.
    /// * error Reports `Error.PEER_NOT_FOUND` if `id` is not recognized.
    Disconnect { id: fidl_fuchsia_bluetooth::PeerId, responder: AccessDisconnectResponder },
    /// Initiate a pairing to the remote `id` with the given `options`.
    /// This call completes only once the pairing procedure has completed or aborted.
    /// Returns an error if no connected peer with `id` is found or the pairing procedure fails.
    /// If the named peer is already paired, this returns immediately with a success value - unless
    /// the pairing is over LE and the PairingOptions.le_security_level is more secure than the
    /// current security level, in which case we will attempt to raise security to the requested
    /// level.
    ///
    /// Pairing will take place over whichever transport is indicated by `options.transport`. If
    /// that transport isn't currently connected, the pairing will fail with `Error.PEER_NOT_FOUND`.
    /// Currently, if DUAL_MODE is requested, we will attempt to pair over the LE transport.
    ///
    /// + request `id` The id of the peer to initiate pairing with
    /// + request `options` The configuration options to use for this pairing request
    /// * error Reports `Error.PEER_NOT_FOUND` if `id` is not recognized, or the peer is not
    ///   connected on the requested transport.
    /// * error Reports `Error.INVALID_ARGUMENTS` if ill-formed options are passed
    /// * error Reports `Error.FAILED` if an error occurs during pairing
    Pair {
        id: fidl_fuchsia_bluetooth::PeerId,
        options: PairingOptions,
        responder: AccessPairResponder,
    },
    /// Removes all bonding information and disconnects any existing links with the peer with the
    /// given `id`.
    ///
    /// + request `id` The id of the peer to forget.
    /// * error Reports `Error.PEER_NOT_FOUND` if `id` is not recognized.
    Forget { id: fidl_fuchsia_bluetooth::PeerId, responder: AccessForgetResponder },
}

impl AccessRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_set_pairing_delegate(
        self,
    ) -> Option<(
        InputCapability,
        OutputCapability,
        fidl::endpoints::ClientEnd<PairingDelegateMarker>,
        AccessControlHandle,
    )> {
        if let AccessRequest::SetPairingDelegate { input, output, delegate, control_handle } = self
        {
            Some((input, output, delegate, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_local_name(self) -> Option<(String, AccessControlHandle)> {
        if let AccessRequest::SetLocalName { name, control_handle } = self {
            Some((name, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_device_class(
        self,
    ) -> Option<(fidl_fuchsia_bluetooth::DeviceClass, AccessControlHandle)> {
        if let AccessRequest::SetDeviceClass { device_class, control_handle } = self {
            Some((device_class, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_make_discoverable(
        self,
    ) -> Option<(fidl::endpoints::ServerEnd<ProcedureTokenMarker>, AccessMakeDiscoverableResponder)>
    {
        if let AccessRequest::MakeDiscoverable { token, responder } = self {
            Some((token, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_connection_policy(
        self,
    ) -> Option<(AccessSetConnectionPolicyRequest, AccessSetConnectionPolicyResponder)> {
        if let AccessRequest::SetConnectionPolicy { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_start_discovery(
        self,
    ) -> Option<(fidl::endpoints::ServerEnd<ProcedureTokenMarker>, AccessStartDiscoveryResponder)>
    {
        if let AccessRequest::StartDiscovery { token, responder } = self {
            Some((token, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_watch_peers(self) -> Option<(AccessWatchPeersResponder)> {
        if let AccessRequest::WatchPeers { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_connect(self) -> Option<(fidl_fuchsia_bluetooth::PeerId, AccessConnectResponder)> {
        if let AccessRequest::Connect { id, responder } = self {
            Some((id, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_disconnect(
        self,
    ) -> Option<(fidl_fuchsia_bluetooth::PeerId, AccessDisconnectResponder)> {
        if let AccessRequest::Disconnect { id, responder } = self {
            Some((id, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_pair(
        self,
    ) -> Option<(fidl_fuchsia_bluetooth::PeerId, PairingOptions, AccessPairResponder)> {
        if let AccessRequest::Pair { id, options, responder } = self {
            Some((id, options, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_forget(self) -> Option<(fidl_fuchsia_bluetooth::PeerId, AccessForgetResponder)> {
        if let AccessRequest::Forget { id, responder } = self {
            Some((id, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            AccessRequest::SetPairingDelegate { .. } => "set_pairing_delegate",
            AccessRequest::SetLocalName { .. } => "set_local_name",
            AccessRequest::SetDeviceClass { .. } => "set_device_class",
            AccessRequest::MakeDiscoverable { .. } => "make_discoverable",
            AccessRequest::SetConnectionPolicy { .. } => "set_connection_policy",
            AccessRequest::StartDiscovery { .. } => "start_discovery",
            AccessRequest::WatchPeers { .. } => "watch_peers",
            AccessRequest::Connect { .. } => "connect",
            AccessRequest::Disconnect { .. } => "disconnect",
            AccessRequest::Pair { .. } => "pair",
            AccessRequest::Forget { .. } => "forget",
        }
    }
}

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

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

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

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

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

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

impl AccessControlHandle {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    fn send_raw(
        &self,
        mut updated: &[Peer],
        mut removed: &[fidl_fuchsia_bluetooth::PeerId],
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<AccessWatchPeersResponse>(
            (updated, removed),
            self.tx_id,
            0x1921fe1ed8e6eb7c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for AddressLookupMarker {
    type Proxy = AddressLookupProxy;
    type RequestStream = AddressLookupRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = AddressLookupSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.bluetooth.sys.AddressLookup";
}
impl fidl::endpoints::DiscoverableProtocolMarker for AddressLookupMarker {}
pub type AddressLookupLookupResult = Result<fidl_fuchsia_bluetooth::Address, LookupError>;

pub trait AddressLookupProxyInterface: Send + Sync {
    type LookupResponseFut: std::future::Future<Output = Result<AddressLookupLookupResult, fidl::Error>>
        + Send;
    fn r#lookup(&self, payload: &AddressLookupLookupRequest) -> Self::LookupResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct AddressLookupSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for AddressLookupSynchronousProxy {
    type Proxy = AddressLookupProxy;
    type Protocol = AddressLookupMarker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl AddressLookupSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

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

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

    pub fn r#lookup(
        &self,
        mut payload: &AddressLookupLookupRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<AddressLookupLookupResult, fidl::Error> {
        let _response = self.client.send_query::<
            AddressLookupLookupRequest,
            fidl::encoding::FlexibleResultType<AddressLookupLookupResponse, LookupError>,
            AddressLookupMarker,
        >(
            payload,
            0x65d2ae252ec22587,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<AddressLookupMarker>("lookup")?;
        Ok(_response.map(|x| x.bd_addr))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for AddressLookupProxy {
    type Protocol = AddressLookupMarker;

    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 AddressLookupProxy {
    /// Create a new Proxy for fuchsia.bluetooth.sys/AddressLookup.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <AddressLookupMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

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

    pub fn r#lookup(
        &self,
        mut payload: &AddressLookupLookupRequest,
    ) -> fidl::client::QueryResponseFut<
        AddressLookupLookupResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        AddressLookupProxyInterface::r#lookup(self, payload)
    }
}

impl AddressLookupProxyInterface for AddressLookupProxy {
    type LookupResponseFut = fidl::client::QueryResponseFut<
        AddressLookupLookupResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#lookup(&self, mut payload: &AddressLookupLookupRequest) -> Self::LookupResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<AddressLookupLookupResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<AddressLookupLookupResponse, LookupError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x65d2ae252ec22587,
            >(_buf?)?
            .into_result::<AddressLookupMarker>("lookup")?;
            Ok(_response.map(|x| x.bd_addr))
        }
        self.client.send_query_and_decode::<AddressLookupLookupRequest, AddressLookupLookupResult>(
            payload,
            0x65d2ae252ec22587,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }
}

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

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.bluetooth.sys/AddressLookup.
pub struct AddressLookupRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for AddressLookupRequestStream {
    type Protocol = AddressLookupMarker;
    type ControlHandle = AddressLookupControlHandle;

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x65d2ae252ec22587 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            AddressLookupLookupRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AddressLookupLookupRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            AddressLookupControlHandle { inner: this.inner.clone() };
                        Ok(AddressLookupRequest::Lookup {
                            payload: req,
                            responder: AddressLookupLookupResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ if header.tx_id == 0
                        && header
                            .dynamic_flags()
                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        Ok(AddressLookupRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: AddressLookupControlHandle {
                                inner: this.inner.clone(),
                            },
                            method_type: fidl::MethodType::OneWay,
                        })
                    }
                    _ if header
                        .dynamic_flags()
                        .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        this.inner.send_framework_err(
                            fidl::encoding::FrameworkErr::UnknownMethod,
                            header.tx_id,
                            header.ordinal,
                            header.dynamic_flags(),
                            (bytes, handles),
                        )?;
                        Ok(AddressLookupRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: AddressLookupControlHandle {
                                inner: this.inner.clone(),
                            },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <AddressLookupMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Protocol used for finding a peer's bluetooth address.
#[derive(Debug)]
pub enum AddressLookupRequest {
    Lookup {
        payload: AddressLookupLookupRequest,
        responder: AddressLookupLookupResponder,
    },
    /// An interaction was received which does not match any known method.
    #[non_exhaustive]
    _UnknownMethod {
        /// Ordinal of the method that was called.
        ordinal: u64,
        control_handle: AddressLookupControlHandle,
        method_type: fidl::MethodType,
    },
}

impl AddressLookupRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_lookup(self) -> Option<(AddressLookupLookupRequest, AddressLookupLookupResponder)> {
        if let AddressLookupRequest::Lookup { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            AddressLookupRequest::Lookup { .. } => "lookup",
            AddressLookupRequest::_UnknownMethod {
                method_type: fidl::MethodType::OneWay, ..
            } => "unknown one-way method",
            AddressLookupRequest::_UnknownMethod {
                method_type: fidl::MethodType::TwoWay, ..
            } => "unknown two-way method",
        }
    }
}

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

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

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

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

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

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

impl AddressLookupControlHandle {}

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

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

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

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

    fn send_raw(
        &self,
        mut result: Result<&fidl_fuchsia_bluetooth::Address, LookupError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
            AddressLookupLookupResponse,
            LookupError,
        >>(
            fidl::encoding::FlexibleResult::new(result.map(|bd_addr| (bd_addr,))),
            self.tx_id,
            0x65d2ae252ec22587,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for BootstrapMarker {
    type Proxy = BootstrapProxy;
    type RequestStream = BootstrapRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = BootstrapSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.bluetooth.sys.Bootstrap";
}
impl fidl::endpoints::DiscoverableProtocolMarker for BootstrapMarker {}
pub type BootstrapCommitResult = Result<(), BootstrapError>;

pub trait BootstrapProxyInterface: Send + Sync {
    fn r#add_identities(&self, identities: &[Identity]) -> Result<(), fidl::Error>;
    type CommitResponseFut: std::future::Future<Output = Result<BootstrapCommitResult, fidl::Error>>
        + Send;
    fn r#commit(&self) -> Self::CommitResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct BootstrapSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for BootstrapSynchronousProxy {
    type Proxy = BootstrapProxy;
    type Protocol = BootstrapMarker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl BootstrapSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

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

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

    /// Adds identities to be added to the unpopulated Bluetooth stack.
    ///
    /// Repeated calls will append identities.
    pub fn r#add_identities(&self, mut identities: &[Identity]) -> Result<(), fidl::Error> {
        self.client.send::<BootstrapAddIdentitiesRequest>(
            (identities,),
            0x92d7c849de29bb0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Writes all added bootstrapping data to the Bluetooth core stack. The server will close the
    /// channel regardless of success. Returns without error if successful and the stack will be
    /// considered initialized even if no bootstrapping data was written. Returns
    /// INVALID_HOST_IDENTITY if any host or bonded peer data is insufficient or inconsistent, with
    /// no effect (the client may retry by obtaining another protocol handle).
    pub fn r#commit(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BootstrapCommitResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, BootstrapError>,
            BootstrapMarker,
        >(
            (),
            0x5288006c9c7db6b7,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for BootstrapProxy {
    type Protocol = BootstrapMarker;

    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 BootstrapProxy {
    /// Create a new Proxy for fuchsia.bluetooth.sys/Bootstrap.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <BootstrapMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

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

    /// Adds identities to be added to the unpopulated Bluetooth stack.
    ///
    /// Repeated calls will append identities.
    pub fn r#add_identities(&self, mut identities: &[Identity]) -> Result<(), fidl::Error> {
        BootstrapProxyInterface::r#add_identities(self, identities)
    }

    /// Writes all added bootstrapping data to the Bluetooth core stack. The server will close the
    /// channel regardless of success. Returns without error if successful and the stack will be
    /// considered initialized even if no bootstrapping data was written. Returns
    /// INVALID_HOST_IDENTITY if any host or bonded peer data is insufficient or inconsistent, with
    /// no effect (the client may retry by obtaining another protocol handle).
    pub fn r#commit(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BootstrapCommitResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BootstrapProxyInterface::r#commit(self)
    }
}

impl BootstrapProxyInterface for BootstrapProxy {
    fn r#add_identities(&self, mut identities: &[Identity]) -> Result<(), fidl::Error> {
        self.client.send::<BootstrapAddIdentitiesRequest>(
            (identities,),
            0x92d7c849de29bb0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

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

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.bluetooth.sys/Bootstrap.
pub struct BootstrapRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for BootstrapRequestStream {
    type Protocol = BootstrapMarker;
    type ControlHandle = BootstrapControlHandle;

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x92d7c849de29bb0 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            BootstrapAddIdentitiesRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BootstrapAddIdentitiesRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BootstrapControlHandle { inner: this.inner.clone() };
                        Ok(BootstrapRequest::AddIdentities {
                            identities: req.identities,

                            control_handle,
                        })
                    }
                    0x5288006c9c7db6b7 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BootstrapControlHandle { inner: this.inner.clone() };
                        Ok(BootstrapRequest::Commit {
                            responder: BootstrapCommitResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <BootstrapMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Protocol used to initialize persistent core Bluetooth data. This protocol populates data that
/// determine the identity of this device as perceived by other Bluetooth devices.
///
/// This protocol can be obtained only before the core Bluetooth host subsystem has generated its
/// own identity. Once initial data is committed, this capability becomes unavailable and remains
/// unavailable even if new Bluetooth adapters are attached.
///
/// Due to the privacy and bonding secrets involved, as well as the capability to make this device
/// assume the Bluetooth identity of another device, this protocol should only be exposed to
/// privileged components that can vouchsafe the origin of the data.
#[derive(Debug)]
pub enum BootstrapRequest {
    /// Adds identities to be added to the unpopulated Bluetooth stack.
    ///
    /// Repeated calls will append identities.
    AddIdentities { identities: Vec<Identity>, control_handle: BootstrapControlHandle },
    /// Writes all added bootstrapping data to the Bluetooth core stack. The server will close the
    /// channel regardless of success. Returns without error if successful and the stack will be
    /// considered initialized even if no bootstrapping data was written. Returns
    /// INVALID_HOST_IDENTITY if any host or bonded peer data is insufficient or inconsistent, with
    /// no effect (the client may retry by obtaining another protocol handle).
    Commit { responder: BootstrapCommitResponder },
}

impl BootstrapRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_add_identities(self) -> Option<(Vec<Identity>, BootstrapControlHandle)> {
        if let BootstrapRequest::AddIdentities { identities, control_handle } = self {
            Some((identities, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_commit(self) -> Option<(BootstrapCommitResponder)> {
        if let BootstrapRequest::Commit { responder } = self { Some((responder)) } else { None }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            BootstrapRequest::AddIdentities { .. } => "add_identities",
            BootstrapRequest::Commit { .. } => "commit",
        }
    }
}

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

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

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

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

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

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

impl BootstrapControlHandle {}

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for ConfigurationMarker {
    type Proxy = ConfigurationProxy;
    type RequestStream = ConfigurationRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ConfigurationSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.bluetooth.sys.Configuration";
}
impl fidl::endpoints::DiscoverableProtocolMarker for ConfigurationMarker {}

pub trait ConfigurationProxyInterface: Send + Sync {
    type UpdateResponseFut: std::future::Future<Output = Result<Settings, fidl::Error>> + Send;
    fn r#update(&self, settings: &Settings) -> Self::UpdateResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ConfigurationSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ConfigurationSynchronousProxy {
    type Proxy = ConfigurationProxy;
    type Protocol = ConfigurationMarker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl ConfigurationSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

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

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

    /// Applies the fields present in `settings` to all bt-host drivers known to the system. Any
    /// fields not present in `settings` will remain unchanged.
    ///
    /// + request `settings` The new settings for active bt-host drivers - only modified settings
    ///   need be present.
    /// - response `result` A fully-populated table with the resultant settings after the new
    ///   settings are applied.
    pub fn r#update(
        &self,
        mut settings: &Settings,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Settings, fidl::Error> {
        let _response = self.client.send_query::<
            ConfigurationUpdateRequest,
            ConfigurationUpdateResponse,
            ConfigurationMarker,
        >(
            (settings,),
            0x27e9cfb72e7c6d01,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.result)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for ConfigurationProxy {
    type Protocol = ConfigurationMarker;

    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 ConfigurationProxy {
    /// Create a new Proxy for fuchsia.bluetooth.sys/Configuration.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <ConfigurationMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

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

    /// Applies the fields present in `settings` to all bt-host drivers known to the system. Any
    /// fields not present in `settings` will remain unchanged.
    ///
    /// + request `settings` The new settings for active bt-host drivers - only modified settings
    ///   need be present.
    /// - response `result` A fully-populated table with the resultant settings after the new
    ///   settings are applied.
    pub fn r#update(
        &self,
        mut settings: &Settings,
    ) -> fidl::client::QueryResponseFut<Settings, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        ConfigurationProxyInterface::r#update(self, settings)
    }
}

impl ConfigurationProxyInterface for ConfigurationProxy {
    type UpdateResponseFut =
        fidl::client::QueryResponseFut<Settings, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#update(&self, mut settings: &Settings) -> Self::UpdateResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Settings, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ConfigurationUpdateResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x27e9cfb72e7c6d01,
            >(_buf?)?;
            Ok(_response.result)
        }
        self.client.send_query_and_decode::<ConfigurationUpdateRequest, Settings>(
            (settings,),
            0x27e9cfb72e7c6d01,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.bluetooth.sys/Configuration.
pub struct ConfigurationRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for ConfigurationRequestStream {
    type Protocol = ConfigurationMarker;
    type ControlHandle = ConfigurationControlHandle;

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x27e9cfb72e7c6d01 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ConfigurationUpdateRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ConfigurationUpdateRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ConfigurationControlHandle { inner: this.inner.clone() };
                        Ok(ConfigurationRequest::Update {
                            settings: req.settings,

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

/// Protocol to configure parameters and features for the core Bluetooth system. These settings
/// apply to all bt-host drivers known to the system.
///
/// This protocol should only be exposed to highly privileged components (e.g. Bluetooth developer
/// tools in a testing/qualification environment).
#[derive(Debug)]
pub enum ConfigurationRequest {
    /// Applies the fields present in `settings` to all bt-host drivers known to the system. Any
    /// fields not present in `settings` will remain unchanged.
    ///
    /// + request `settings` The new settings for active bt-host drivers - only modified settings
    ///   need be present.
    /// - response `result` A fully-populated table with the resultant settings after the new
    ///   settings are applied.
    Update { settings: Settings, responder: ConfigurationUpdateResponder },
}

impl ConfigurationRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_update(self) -> Option<(Settings, ConfigurationUpdateResponder)> {
        if let ConfigurationRequest::Update { settings, responder } = self {
            Some((settings, responder))
        } else {
            None
        }
    }

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

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

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

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

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

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

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

impl ConfigurationControlHandle {}

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

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

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

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

    fn send_raw(&self, mut result: &Settings) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<ConfigurationUpdateResponse>(
            (result,),
            self.tx_id,
            0x27e9cfb72e7c6d01,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for HostWatcherMarker {
    type Proxy = HostWatcherProxy;
    type RequestStream = HostWatcherRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = HostWatcherSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.bluetooth.sys.HostWatcher";
}
impl fidl::endpoints::DiscoverableProtocolMarker for HostWatcherMarker {}
pub type HostWatcherSetActiveResult = Result<(), i32>;

pub trait HostWatcherProxyInterface: Send + Sync {
    type WatchResponseFut: std::future::Future<Output = Result<Vec<HostInfo>, fidl::Error>> + Send;
    fn r#watch(&self) -> Self::WatchResponseFut;
    type SetActiveResponseFut: std::future::Future<Output = Result<HostWatcherSetActiveResult, fidl::Error>>
        + Send;
    fn r#set_active(&self, id: &fidl_fuchsia_bluetooth::HostId) -> Self::SetActiveResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct HostWatcherSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for HostWatcherSynchronousProxy {
    type Proxy = HostWatcherProxy;
    type Protocol = HostWatcherMarker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl HostWatcherSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

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

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

    /// Obtain a list of all available Bluetooth controllers and their state. A response is sent
    /// only if this list has changed since the last time the client has sent this message.
    pub fn r#watch(&self, ___deadline: zx::MonotonicInstant) -> Result<Vec<HostInfo>, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            HostWatcherWatchResponse,
            HostWatcherMarker,
        >(
            (),
            0x4e2c2972a5b16f9c,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.hosts)
    }

    /// Designates the host with the given `id` as active. All Bluetooth procedures will be routed
    /// over this host. Any previously assigned active host will be disabled and all of its pending
    /// procedures will be terminated.
    ///
    /// * error This can fail if a host with `id` was not found.
    pub fn r#set_active(
        &self,
        mut id: &fidl_fuchsia_bluetooth::HostId,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<HostWatcherSetActiveResult, fidl::Error> {
        let _response = self.client.send_query::<
            HostWatcherSetActiveRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            HostWatcherMarker,
        >(
            (id,),
            0x83f311ecaf0ddf3,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for HostWatcherProxy {
    type Protocol = HostWatcherMarker;

    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 HostWatcherProxy {
    /// Create a new Proxy for fuchsia.bluetooth.sys/HostWatcher.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <HostWatcherMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

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

    /// Obtain a list of all available Bluetooth controllers and their state. A response is sent
    /// only if this list has changed since the last time the client has sent this message.
    pub fn r#watch(
        &self,
    ) -> fidl::client::QueryResponseFut<Vec<HostInfo>, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        HostWatcherProxyInterface::r#watch(self)
    }

    /// Designates the host with the given `id` as active. All Bluetooth procedures will be routed
    /// over this host. Any previously assigned active host will be disabled and all of its pending
    /// procedures will be terminated.
    ///
    /// * error This can fail if a host with `id` was not found.
    pub fn r#set_active(
        &self,
        mut id: &fidl_fuchsia_bluetooth::HostId,
    ) -> fidl::client::QueryResponseFut<
        HostWatcherSetActiveResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        HostWatcherProxyInterface::r#set_active(self, id)
    }
}

impl HostWatcherProxyInterface for HostWatcherProxy {
    type WatchResponseFut = fidl::client::QueryResponseFut<
        Vec<HostInfo>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#watch(&self) -> Self::WatchResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<HostInfo>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                HostWatcherWatchResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4e2c2972a5b16f9c,
            >(_buf?)?;
            Ok(_response.hosts)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<HostInfo>>(
            (),
            0x4e2c2972a5b16f9c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetActiveResponseFut = fidl::client::QueryResponseFut<
        HostWatcherSetActiveResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_active(&self, mut id: &fidl_fuchsia_bluetooth::HostId) -> Self::SetActiveResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<HostWatcherSetActiveResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x83f311ecaf0ddf3,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<HostWatcherSetActiveRequest, HostWatcherSetActiveResult>(
                (id,),
                0x83f311ecaf0ddf3,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }
}

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

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.bluetooth.sys/HostWatcher.
pub struct HostWatcherRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for HostWatcherRequestStream {
    type Protocol = HostWatcherMarker;
    type ControlHandle = HostWatcherControlHandle;

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x4e2c2972a5b16f9c => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = HostWatcherControlHandle { inner: this.inner.clone() };
                        Ok(HostWatcherRequest::Watch {
                            responder: HostWatcherWatchResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x83f311ecaf0ddf3 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            HostWatcherSetActiveRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<HostWatcherSetActiveRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = HostWatcherControlHandle { inner: this.inner.clone() };
                        Ok(HostWatcherRequest::SetActive {
                            id: req.id,

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

/// Protocol used to observe and manage the Bluetooth controllers on the system.
#[derive(Debug)]
pub enum HostWatcherRequest {
    /// Obtain a list of all available Bluetooth controllers and their state. A response is sent
    /// only if this list has changed since the last time the client has sent this message.
    Watch { responder: HostWatcherWatchResponder },
    /// Designates the host with the given `id` as active. All Bluetooth procedures will be routed
    /// over this host. Any previously assigned active host will be disabled and all of its pending
    /// procedures will be terminated.
    ///
    /// * error This can fail if a host with `id` was not found.
    SetActive { id: fidl_fuchsia_bluetooth::HostId, responder: HostWatcherSetActiveResponder },
}

impl HostWatcherRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_watch(self) -> Option<(HostWatcherWatchResponder)> {
        if let HostWatcherRequest::Watch { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_active(
        self,
    ) -> Option<(fidl_fuchsia_bluetooth::HostId, HostWatcherSetActiveResponder)> {
        if let HostWatcherRequest::SetActive { id, responder } = self {
            Some((id, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            HostWatcherRequest::Watch { .. } => "watch",
            HostWatcherRequest::SetActive { .. } => "set_active",
        }
    }
}

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

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

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

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

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

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

impl HostWatcherControlHandle {}

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

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

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

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

    fn send_raw(&self, mut hosts: &[HostInfo]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<HostWatcherWatchResponse>(
            (hosts,),
            self.tx_id,
            0x4e2c2972a5b16f9c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for PairingMarker {
    type Proxy = PairingProxy;
    type RequestStream = PairingRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = PairingSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.bluetooth.sys.Pairing";
}
impl fidl::endpoints::DiscoverableProtocolMarker for PairingMarker {}

pub trait PairingProxyInterface: Send + Sync {
    fn r#set_pairing_delegate(
        &self,
        input: InputCapability,
        output: OutputCapability,
        delegate: fidl::endpoints::ClientEnd<PairingDelegateMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#set_delegate(
        &self,
        input: InputCapability,
        output: OutputCapability,
        delegate: fidl::endpoints::ClientEnd<PairingDelegate2Marker>,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct PairingSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for PairingSynchronousProxy {
    type Proxy = PairingProxy;
    type Protocol = PairingMarker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl PairingSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

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

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

    /// Assign a PairingDelegate to respond to pairing procedures. The provided I/O capabilities
    /// will be used to determine the pairing methods used.
    ///
    /// Only one PairingDelegate can be set at a time system-wide - if this is called
    /// while another delegate is set, the new delegate will be closed immediately.
    /// Closing a PairingDelegate after it is set aborts all ongoing pairing procedures
    /// without accepting and unsets the delegate.
    ///
    /// If no PairingDelegate is set, all pairings will be rejected even if the
    /// peer connection was initiated by the local device.
    ///
    /// + request `input` Bluetooth input capability, see `InputCapability`
    /// + request `output` Bluetooth output capability, see `OutputCapability`
    /// + request `delegate` PairingDelegate which will receive pairing requests
    pub fn r#set_pairing_delegate(
        &self,
        mut input: InputCapability,
        mut output: OutputCapability,
        mut delegate: fidl::endpoints::ClientEnd<PairingDelegateMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PairingSetPairingDelegateRequest>(
            (input, output, delegate),
            0x19721a12cb80212c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Assign a PairingDelegate2 to handle pairing procedures.  The provided
    /// I/O capabilities will be used to determine the methods used.
    ///
    /// Only one of PairingDelegate or PairingDelegate2 can be set at a time
    /// system-wide.  If this is called while another delegate is set, the new
    /// delegate will be closed immediately.
    ///
    /// Closing a PairingDelegate2 unsets the pairing delegate. Ongoing
    /// PairingRequests can still be completed, but new requests will act as if
    /// no delegate is set.
    ///
    /// If no delegate is set, all pairings will be rejected even if the
    /// peer connection was initiated by the local device.
    ///
    /// + request `input` Bluetooth input capability, see `InputCapability`
    /// + request `output` Bluetooth output capability, see `OutputCapability`
    /// + request `delegate` PairingDelegate2 which will receive pairing requests
    pub fn r#set_delegate(
        &self,
        mut input: InputCapability,
        mut output: OutputCapability,
        mut delegate: fidl::endpoints::ClientEnd<PairingDelegate2Marker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PairingSetDelegateRequest>(
            (input, output, delegate),
            0x1da0568d2582a9a5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for PairingProxy {
    type Protocol = PairingMarker;

    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 PairingProxy {
    /// Create a new Proxy for fuchsia.bluetooth.sys/Pairing.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <PairingMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

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

    /// Assign a PairingDelegate to respond to pairing procedures. The provided I/O capabilities
    /// will be used to determine the pairing methods used.
    ///
    /// Only one PairingDelegate can be set at a time system-wide - if this is called
    /// while another delegate is set, the new delegate will be closed immediately.
    /// Closing a PairingDelegate after it is set aborts all ongoing pairing procedures
    /// without accepting and unsets the delegate.
    ///
    /// If no PairingDelegate is set, all pairings will be rejected even if the
    /// peer connection was initiated by the local device.
    ///
    /// + request `input` Bluetooth input capability, see `InputCapability`
    /// + request `output` Bluetooth output capability, see `OutputCapability`
    /// + request `delegate` PairingDelegate which will receive pairing requests
    pub fn r#set_pairing_delegate(
        &self,
        mut input: InputCapability,
        mut output: OutputCapability,
        mut delegate: fidl::endpoints::ClientEnd<PairingDelegateMarker>,
    ) -> Result<(), fidl::Error> {
        PairingProxyInterface::r#set_pairing_delegate(self, input, output, delegate)
    }

    /// Assign a PairingDelegate2 to handle pairing procedures.  The provided
    /// I/O capabilities will be used to determine the methods used.
    ///
    /// Only one of PairingDelegate or PairingDelegate2 can be set at a time
    /// system-wide.  If this is called while another delegate is set, the new
    /// delegate will be closed immediately.
    ///
    /// Closing a PairingDelegate2 unsets the pairing delegate. Ongoing
    /// PairingRequests can still be completed, but new requests will act as if
    /// no delegate is set.
    ///
    /// If no delegate is set, all pairings will be rejected even if the
    /// peer connection was initiated by the local device.
    ///
    /// + request `input` Bluetooth input capability, see `InputCapability`
    /// + request `output` Bluetooth output capability, see `OutputCapability`
    /// + request `delegate` PairingDelegate2 which will receive pairing requests
    pub fn r#set_delegate(
        &self,
        mut input: InputCapability,
        mut output: OutputCapability,
        mut delegate: fidl::endpoints::ClientEnd<PairingDelegate2Marker>,
    ) -> Result<(), fidl::Error> {
        PairingProxyInterface::r#set_delegate(self, input, output, delegate)
    }
}

impl PairingProxyInterface for PairingProxy {
    fn r#set_pairing_delegate(
        &self,
        mut input: InputCapability,
        mut output: OutputCapability,
        mut delegate: fidl::endpoints::ClientEnd<PairingDelegateMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PairingSetPairingDelegateRequest>(
            (input, output, delegate),
            0x19721a12cb80212c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_delegate(
        &self,
        mut input: InputCapability,
        mut output: OutputCapability,
        mut delegate: fidl::endpoints::ClientEnd<PairingDelegate2Marker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PairingSetDelegateRequest>(
            (input, output, delegate),
            0x1da0568d2582a9a5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.bluetooth.sys/Pairing.
pub struct PairingRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for PairingRequestStream {
    type Protocol = PairingMarker;
    type ControlHandle = PairingControlHandle;

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x19721a12cb80212c => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PairingSetPairingDelegateRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PairingSetPairingDelegateRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PairingControlHandle { inner: this.inner.clone() };
                        Ok(PairingRequest::SetPairingDelegate {
                            input: req.input,
                            output: req.output,
                            delegate: req.delegate,

                            control_handle,
                        })
                    }
                    0x1da0568d2582a9a5 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PairingSetDelegateRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PairingSetDelegateRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PairingControlHandle { inner: this.inner.clone() };
                        Ok(PairingRequest::SetDelegate {
                            input: req.input,
                            output: req.output,
                            delegate: req.delegate,

                            control_handle,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <PairingMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Allows system clients to enable Bluetooth pairing.
#[derive(Debug)]
pub enum PairingRequest {
    /// Assign a PairingDelegate to respond to pairing procedures. The provided I/O capabilities
    /// will be used to determine the pairing methods used.
    ///
    /// Only one PairingDelegate can be set at a time system-wide - if this is called
    /// while another delegate is set, the new delegate will be closed immediately.
    /// Closing a PairingDelegate after it is set aborts all ongoing pairing procedures
    /// without accepting and unsets the delegate.
    ///
    /// If no PairingDelegate is set, all pairings will be rejected even if the
    /// peer connection was initiated by the local device.
    ///
    /// + request `input` Bluetooth input capability, see `InputCapability`
    /// + request `output` Bluetooth output capability, see `OutputCapability`
    /// + request `delegate` PairingDelegate which will receive pairing requests
    SetPairingDelegate {
        input: InputCapability,
        output: OutputCapability,
        delegate: fidl::endpoints::ClientEnd<PairingDelegateMarker>,
        control_handle: PairingControlHandle,
    },
    /// Assign a PairingDelegate2 to handle pairing procedures.  The provided
    /// I/O capabilities will be used to determine the methods used.
    ///
    /// Only one of PairingDelegate or PairingDelegate2 can be set at a time
    /// system-wide.  If this is called while another delegate is set, the new
    /// delegate will be closed immediately.
    ///
    /// Closing a PairingDelegate2 unsets the pairing delegate. Ongoing
    /// PairingRequests can still be completed, but new requests will act as if
    /// no delegate is set.
    ///
    /// If no delegate is set, all pairings will be rejected even if the
    /// peer connection was initiated by the local device.
    ///
    /// + request `input` Bluetooth input capability, see `InputCapability`
    /// + request `output` Bluetooth output capability, see `OutputCapability`
    /// + request `delegate` PairingDelegate2 which will receive pairing requests
    SetDelegate {
        input: InputCapability,
        output: OutputCapability,
        delegate: fidl::endpoints::ClientEnd<PairingDelegate2Marker>,
        control_handle: PairingControlHandle,
    },
}

impl PairingRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_set_pairing_delegate(
        self,
    ) -> Option<(
        InputCapability,
        OutputCapability,
        fidl::endpoints::ClientEnd<PairingDelegateMarker>,
        PairingControlHandle,
    )> {
        if let PairingRequest::SetPairingDelegate { input, output, delegate, control_handle } = self
        {
            Some((input, output, delegate, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_delegate(
        self,
    ) -> Option<(
        InputCapability,
        OutputCapability,
        fidl::endpoints::ClientEnd<PairingDelegate2Marker>,
        PairingControlHandle,
    )> {
        if let PairingRequest::SetDelegate { input, output, delegate, control_handle } = self {
            Some((input, output, delegate, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            PairingRequest::SetPairingDelegate { .. } => "set_pairing_delegate",
            PairingRequest::SetDelegate { .. } => "set_delegate",
        }
    }
}

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

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

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

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

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

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

impl PairingControlHandle {}

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

impl fidl::endpoints::ProtocolMarker for PairingDelegateMarker {
    type Proxy = PairingDelegateProxy;
    type RequestStream = PairingDelegateRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = PairingDelegateSynchronousProxy;

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

pub trait PairingDelegateProxyInterface: Send + Sync {
    type OnPairingRequestResponseFut: std::future::Future<Output = Result<(bool, u32), fidl::Error>>
        + Send;
    fn r#on_pairing_request(
        &self,
        peer: &Peer,
        method: PairingMethod,
        displayed_passkey: u32,
    ) -> Self::OnPairingRequestResponseFut;
    fn r#on_pairing_complete(
        &self,
        id: &fidl_fuchsia_bluetooth::PeerId,
        success: bool,
    ) -> Result<(), fidl::Error>;
    fn r#on_remote_keypress(
        &self,
        id: &fidl_fuchsia_bluetooth::PeerId,
        keypress: PairingKeypress,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct PairingDelegateSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for PairingDelegateSynchronousProxy {
    type Proxy = PairingDelegateProxy;
    type Protocol = PairingDelegateMarker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl PairingDelegateSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

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

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

    /// Called to confirm a pairing. The pairing process will be continued if
    /// `accept` response is true and rejected otherwise.
    /// If the pairing method requires a passkey it must be included as well.
    /// Pairing methods that do not require a passkey ignore the `entered_passkey`
    /// repsonse.
    ///
    /// The pairing can fail (usually by timeout or peer disconnect) before the
    /// response is received. The OnPairingComplete method will be called when this
    /// occurs.  Any response sent in this case will be ignored.
    ///
    /// + request `peer` information about the peer being paired
    /// + request `method` method of pairing active. See `PairingMethod`
    /// + request `displayed_passkey` a passkey to display to the user if
    ///   PASSKEY_DISPLAY or PASSKEY_COMPARISON is being used. Meaningless
    ///   otherwise.
    /// - response `accept` true if the pairing is accepted
    /// - response `entered_passkey` passkey entered by the user. Ignored unless
    ///   method is PASSKEY_ENTRY.
    pub fn r#on_pairing_request(
        &self,
        mut peer: &Peer,
        mut method: PairingMethod,
        mut displayed_passkey: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(bool, u32), fidl::Error> {
        let _response = self.client.send_query::<
            PairingDelegateOnPairingRequestRequest,
            PairingDelegateOnPairingRequestResponse,
            PairingDelegateMarker,
        >(
            (peer, method, displayed_passkey,),
            0x5c483a8f97b226b3,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok((_response.accept, _response.entered_passkey))
    }

    /// Called when the pairing procedure for a peer has been completed.
    /// This can be due to successful completion or an error (e.g. due to cancellation
    /// by the peer, a timeout, or disconnection).
    /// * request `id` The Bluetooth peer ID of the peer which was being paired.
    /// * request `success` true if the pairing succeeded, otherwise false.
    pub fn r#on_pairing_complete(
        &self,
        mut id: &fidl_fuchsia_bluetooth::PeerId,
        mut success: bool,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PairingDelegateOnPairingCompleteRequest>(
            (id, success),
            0x5ad8fc9864eba757,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Called to notify keypresses from the peer device during pairing using
    /// `PairingMethod.PASSKEY_DISPLAY`.
    ///
    /// This event is used to provide key press events to the delegate for a responsive user
    /// experience as the user types the passkey on the peer device. This event will be called
    /// once for each keypress.
    ///
    /// This event will only be called between when an OnPairingRequest has been sent for
    /// `id` and when OnPairingComplete is sent.
    ///
    /// Note: many devices do not send these events
    /// * request `id` The peer id of the peer that sent the keypress event.
    /// * request `keypress` The type of event which was received.
    pub fn r#on_remote_keypress(
        &self,
        mut id: &fidl_fuchsia_bluetooth::PeerId,
        mut keypress: PairingKeypress,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PairingDelegateOnRemoteKeypressRequest>(
            (id, keypress),
            0x4e341e41c604c724,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for PairingDelegateProxy {
    type Protocol = PairingDelegateMarker;

    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 PairingDelegateProxy {
    /// Create a new Proxy for fuchsia.bluetooth.sys/PairingDelegate.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <PairingDelegateMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

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

    /// Called to confirm a pairing. The pairing process will be continued if
    /// `accept` response is true and rejected otherwise.
    /// If the pairing method requires a passkey it must be included as well.
    /// Pairing methods that do not require a passkey ignore the `entered_passkey`
    /// repsonse.
    ///
    /// The pairing can fail (usually by timeout or peer disconnect) before the
    /// response is received. The OnPairingComplete method will be called when this
    /// occurs.  Any response sent in this case will be ignored.
    ///
    /// + request `peer` information about the peer being paired
    /// + request `method` method of pairing active. See `PairingMethod`
    /// + request `displayed_passkey` a passkey to display to the user if
    ///   PASSKEY_DISPLAY or PASSKEY_COMPARISON is being used. Meaningless
    ///   otherwise.
    /// - response `accept` true if the pairing is accepted
    /// - response `entered_passkey` passkey entered by the user. Ignored unless
    ///   method is PASSKEY_ENTRY.
    pub fn r#on_pairing_request(
        &self,
        mut peer: &Peer,
        mut method: PairingMethod,
        mut displayed_passkey: u32,
    ) -> fidl::client::QueryResponseFut<(bool, u32), fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        PairingDelegateProxyInterface::r#on_pairing_request(self, peer, method, displayed_passkey)
    }

    /// Called when the pairing procedure for a peer has been completed.
    /// This can be due to successful completion or an error (e.g. due to cancellation
    /// by the peer, a timeout, or disconnection).
    /// * request `id` The Bluetooth peer ID of the peer which was being paired.
    /// * request `success` true if the pairing succeeded, otherwise false.
    pub fn r#on_pairing_complete(
        &self,
        mut id: &fidl_fuchsia_bluetooth::PeerId,
        mut success: bool,
    ) -> Result<(), fidl::Error> {
        PairingDelegateProxyInterface::r#on_pairing_complete(self, id, success)
    }

    /// Called to notify keypresses from the peer device during pairing using
    /// `PairingMethod.PASSKEY_DISPLAY`.
    ///
    /// This event is used to provide key press events to the delegate for a responsive user
    /// experience as the user types the passkey on the peer device. This event will be called
    /// once for each keypress.
    ///
    /// This event will only be called between when an OnPairingRequest has been sent for
    /// `id` and when OnPairingComplete is sent.
    ///
    /// Note: many devices do not send these events
    /// * request `id` The peer id of the peer that sent the keypress event.
    /// * request `keypress` The type of event which was received.
    pub fn r#on_remote_keypress(
        &self,
        mut id: &fidl_fuchsia_bluetooth::PeerId,
        mut keypress: PairingKeypress,
    ) -> Result<(), fidl::Error> {
        PairingDelegateProxyInterface::r#on_remote_keypress(self, id, keypress)
    }
}

impl PairingDelegateProxyInterface for PairingDelegateProxy {
    type OnPairingRequestResponseFut =
        fidl::client::QueryResponseFut<(bool, u32), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#on_pairing_request(
        &self,
        mut peer: &Peer,
        mut method: PairingMethod,
        mut displayed_passkey: u32,
    ) -> Self::OnPairingRequestResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(bool, u32), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                PairingDelegateOnPairingRequestResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5c483a8f97b226b3,
            >(_buf?)?;
            Ok((_response.accept, _response.entered_passkey))
        }
        self.client.send_query_and_decode::<PairingDelegateOnPairingRequestRequest, (bool, u32)>(
            (peer, method, displayed_passkey),
            0x5c483a8f97b226b3,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#on_pairing_complete(
        &self,
        mut id: &fidl_fuchsia_bluetooth::PeerId,
        mut success: bool,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PairingDelegateOnPairingCompleteRequest>(
            (id, success),
            0x5ad8fc9864eba757,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#on_remote_keypress(
        &self,
        mut id: &fidl_fuchsia_bluetooth::PeerId,
        mut keypress: PairingKeypress,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PairingDelegateOnRemoteKeypressRequest>(
            (id, keypress),
            0x4e341e41c604c724,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

#[derive(Debug)]
pub enum PairingDelegateEvent {
    OnLocalKeypress { id: fidl_fuchsia_bluetooth::PeerId, keypress: PairingKeypress },
}

impl PairingDelegateEvent {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_local_keypress(
        self,
    ) -> Option<(fidl_fuchsia_bluetooth::PeerId, PairingKeypress)> {
        if let PairingDelegateEvent::OnLocalKeypress { id, keypress } = self {
            Some((id, keypress))
        } else {
            None
        }
    }

    /// Decodes a message buffer as a [`PairingDelegateEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<PairingDelegateEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            0x1a764c0428878889 => {
                let mut out = fidl::new_empty!(
                    PairingDelegateOnLocalKeypressRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PairingDelegateOnLocalKeypressRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((PairingDelegateEvent::OnLocalKeypress { id: out.id, keypress: out.keypress }))
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name:
                    <PairingDelegateMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.bluetooth.sys/PairingDelegate.
pub struct PairingDelegateRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for PairingDelegateRequestStream {
    type Protocol = PairingDelegateMarker;
    type ControlHandle = PairingDelegateControlHandle;

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x5c483a8f97b226b3 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            PairingDelegateOnPairingRequestRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PairingDelegateOnPairingRequestRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            PairingDelegateControlHandle { inner: this.inner.clone() };
                        Ok(PairingDelegateRequest::OnPairingRequest {
                            peer: req.peer,
                            method: req.method,
                            displayed_passkey: req.displayed_passkey,

                            responder: PairingDelegateOnPairingRequestResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5ad8fc9864eba757 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PairingDelegateOnPairingCompleteRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PairingDelegateOnPairingCompleteRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            PairingDelegateControlHandle { inner: this.inner.clone() };
                        Ok(PairingDelegateRequest::OnPairingComplete {
                            id: req.id,
                            success: req.success,

                            control_handle,
                        })
                    }
                    0x4e341e41c604c724 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PairingDelegateOnRemoteKeypressRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PairingDelegateOnRemoteKeypressRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            PairingDelegateControlHandle { inner: this.inner.clone() };
                        Ok(PairingDelegateRequest::OnRemoteKeypress {
                            id: req.id,
                            keypress: req.keypress,

                            control_handle,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <PairingDelegateMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// A Bluetooth Pairing Delegate is responsible for confirming or denying
/// pairing requests received from Bluetooth peers that connect or are
/// being connected to the local device.
///
/// Any new pairing will result in a call to `PairingDelegate.OnPairingRequest`,
/// including pairings where the InputCapability and OutputCapability are set
/// to none. The delegate is expected to have enough context to derive whether
/// to accept or deny the pairing.
///
/// Only one delegate is allowed to be set per system at a time. See
/// `fuchsia.bluetooth.sys.Pairing` for how to set the pairing delegate.
#[derive(Debug)]
pub enum PairingDelegateRequest {
    /// Called to confirm a pairing. The pairing process will be continued if
    /// `accept` response is true and rejected otherwise.
    /// If the pairing method requires a passkey it must be included as well.
    /// Pairing methods that do not require a passkey ignore the `entered_passkey`
    /// repsonse.
    ///
    /// The pairing can fail (usually by timeout or peer disconnect) before the
    /// response is received. The OnPairingComplete method will be called when this
    /// occurs.  Any response sent in this case will be ignored.
    ///
    /// + request `peer` information about the peer being paired
    /// + request `method` method of pairing active. See `PairingMethod`
    /// + request `displayed_passkey` a passkey to display to the user if
    ///   PASSKEY_DISPLAY or PASSKEY_COMPARISON is being used. Meaningless
    ///   otherwise.
    /// - response `accept` true if the pairing is accepted
    /// - response `entered_passkey` passkey entered by the user. Ignored unless
    ///   method is PASSKEY_ENTRY.
    OnPairingRequest {
        peer: Peer,
        method: PairingMethod,
        displayed_passkey: u32,
        responder: PairingDelegateOnPairingRequestResponder,
    },
    /// Called when the pairing procedure for a peer has been completed.
    /// This can be due to successful completion or an error (e.g. due to cancellation
    /// by the peer, a timeout, or disconnection).
    /// * request `id` The Bluetooth peer ID of the peer which was being paired.
    /// * request `success` true if the pairing succeeded, otherwise false.
    OnPairingComplete {
        id: fidl_fuchsia_bluetooth::PeerId,
        success: bool,
        control_handle: PairingDelegateControlHandle,
    },
    /// Called to notify keypresses from the peer device during pairing using
    /// `PairingMethod.PASSKEY_DISPLAY`.
    ///
    /// This event is used to provide key press events to the delegate for a responsive user
    /// experience as the user types the passkey on the peer device. This event will be called
    /// once for each keypress.
    ///
    /// This event will only be called between when an OnPairingRequest has been sent for
    /// `id` and when OnPairingComplete is sent.
    ///
    /// Note: many devices do not send these events
    /// * request `id` The peer id of the peer that sent the keypress event.
    /// * request `keypress` The type of event which was received.
    OnRemoteKeypress {
        id: fidl_fuchsia_bluetooth::PeerId,
        keypress: PairingKeypress,
        control_handle: PairingDelegateControlHandle,
    },
}

impl PairingDelegateRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_pairing_request(
        self,
    ) -> Option<(Peer, PairingMethod, u32, PairingDelegateOnPairingRequestResponder)> {
        if let PairingDelegateRequest::OnPairingRequest {
            peer,
            method,
            displayed_passkey,
            responder,
        } = self
        {
            Some((peer, method, displayed_passkey, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_on_pairing_complete(
        self,
    ) -> Option<(fidl_fuchsia_bluetooth::PeerId, bool, PairingDelegateControlHandle)> {
        if let PairingDelegateRequest::OnPairingComplete { id, success, control_handle } = self {
            Some((id, success, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_on_remote_keypress(
        self,
    ) -> Option<(fidl_fuchsia_bluetooth::PeerId, PairingKeypress, PairingDelegateControlHandle)>
    {
        if let PairingDelegateRequest::OnRemoteKeypress { id, keypress, control_handle } = self {
            Some((id, keypress, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            PairingDelegateRequest::OnPairingRequest { .. } => "on_pairing_request",
            PairingDelegateRequest::OnPairingComplete { .. } => "on_pairing_complete",
            PairingDelegateRequest::OnRemoteKeypress { .. } => "on_remote_keypress",
        }
    }
}

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

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

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

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

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

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

impl PairingDelegateControlHandle {
    pub fn send_on_local_keypress(
        &self,
        mut id: &fidl_fuchsia_bluetooth::PeerId,
        mut keypress: PairingKeypress,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<PairingDelegateOnLocalKeypressRequest>(
            (id, keypress),
            0,
            0x1a764c0428878889,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

    fn send_raw(&self, mut accept: bool, mut entered_passkey: u32) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<PairingDelegateOnPairingRequestResponse>(
            (accept, entered_passkey),
            self.tx_id,
            0x5c483a8f97b226b3,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for PairingDelegate2Marker {
    type Proxy = PairingDelegate2Proxy;
    type RequestStream = PairingDelegate2RequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = PairingDelegate2SynchronousProxy;

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

pub trait PairingDelegate2ProxyInterface: Send + Sync {
    fn r#start_request(
        &self,
        payload: PairingDelegate2StartRequestRequest,
    ) -> Result<(), fidl::Error>;
    fn r#request_complete(
        &self,
        id: &fidl_fuchsia_bluetooth::PeerId,
        success: bool,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct PairingDelegate2SynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for PairingDelegate2SynchronousProxy {
    type Proxy = PairingDelegate2Proxy;
    type Protocol = PairingDelegate2Marker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl PairingDelegate2SynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

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

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

    /// Called when a pairing with `peer` is started. The pairing process is
    /// continued using the PairingRequest protocol.
    ///
    /// The properties of the pairing are provided in `info` which indicates
    /// what type of interaction is intended locally.
    ///
    /// Multiple requests can be active at one time for different peers, and
    /// requests can outlive this protocol.  Dropping the request protocol will
    /// automatically reject the pairing.
    ///
    /// All fields will always be present.
    pub fn r#start_request(
        &self,
        mut payload: PairingDelegate2StartRequestRequest,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PairingDelegate2StartRequestRequest>(
            &mut payload,
            0x2a5ab8092a961a01,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Called when the pairing procedure for a peer has been completed.  This
    /// can be due to successful completion or an error (e.g. due to
    /// cancellation by the peer, a timeout, or disconnection).
    ///
    /// + request `id` The Bluetooth peer ID of the peer which was being paired
    /// + request `success` true if the pairing succeeded, otherwise false
    pub fn r#request_complete(
        &self,
        mut id: &fidl_fuchsia_bluetooth::PeerId,
        mut success: bool,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PairingDelegate2RequestCompleteRequest>(
            (id, success),
            0x4b63b44d5dbca192,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for PairingDelegate2Proxy {
    type Protocol = PairingDelegate2Marker;

    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 PairingDelegate2Proxy {
    /// Create a new Proxy for fuchsia.bluetooth.sys/PairingDelegate2.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <PairingDelegate2Marker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

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

    /// Called when a pairing with `peer` is started. The pairing process is
    /// continued using the PairingRequest protocol.
    ///
    /// The properties of the pairing are provided in `info` which indicates
    /// what type of interaction is intended locally.
    ///
    /// Multiple requests can be active at one time for different peers, and
    /// requests can outlive this protocol.  Dropping the request protocol will
    /// automatically reject the pairing.
    ///
    /// All fields will always be present.
    pub fn r#start_request(
        &self,
        mut payload: PairingDelegate2StartRequestRequest,
    ) -> Result<(), fidl::Error> {
        PairingDelegate2ProxyInterface::r#start_request(self, payload)
    }

    /// Called when the pairing procedure for a peer has been completed.  This
    /// can be due to successful completion or an error (e.g. due to
    /// cancellation by the peer, a timeout, or disconnection).
    ///
    /// + request `id` The Bluetooth peer ID of the peer which was being paired
    /// + request `success` true if the pairing succeeded, otherwise false
    pub fn r#request_complete(
        &self,
        mut id: &fidl_fuchsia_bluetooth::PeerId,
        mut success: bool,
    ) -> Result<(), fidl::Error> {
        PairingDelegate2ProxyInterface::r#request_complete(self, id, success)
    }
}

impl PairingDelegate2ProxyInterface for PairingDelegate2Proxy {
    fn r#start_request(
        &self,
        mut payload: PairingDelegate2StartRequestRequest,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PairingDelegate2StartRequestRequest>(
            &mut payload,
            0x2a5ab8092a961a01,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#request_complete(
        &self,
        mut id: &fidl_fuchsia_bluetooth::PeerId,
        mut success: bool,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PairingDelegate2RequestCompleteRequest>(
            (id, success),
            0x4b63b44d5dbca192,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.bluetooth.sys/PairingDelegate2.
pub struct PairingDelegate2RequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for PairingDelegate2RequestStream {
    type Protocol = PairingDelegate2Marker;
    type ControlHandle = PairingDelegate2ControlHandle;

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x2a5ab8092a961a01 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PairingDelegate2StartRequestRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PairingDelegate2StartRequestRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            PairingDelegate2ControlHandle { inner: this.inner.clone() };
                        Ok(PairingDelegate2Request::StartRequest { payload: req, control_handle })
                    }
                    0x4b63b44d5dbca192 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PairingDelegate2RequestCompleteRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PairingDelegate2RequestCompleteRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            PairingDelegate2ControlHandle { inner: this.inner.clone() };
                        Ok(PairingDelegate2Request::RequestComplete {
                            id: req.id,
                            success: req.success,

                            control_handle,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <PairingDelegate2Marker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// A Bluetooth Pairing Delegate is responsible for confirming or denying
/// pairing requests received from Bluetooth peers that connect or are
/// being connected to the local device.
///
/// Any new pairing will result in a call to `PairingDelegate.StartRequest`,
/// including pairings where the InputCapability and OutputCapability are set
/// to none. The delegate is expected to have enough context to derive whether
/// to accept or reject the pairing.
///
/// Only one delegate is allowed to be set per system at a time. See
/// `fuchsia.bluetooth.sys.Pairing` for how to set the pairing delegate.
#[derive(Debug)]
pub enum PairingDelegate2Request {
    /// Called when a pairing with `peer` is started. The pairing process is
    /// continued using the PairingRequest protocol.
    ///
    /// The properties of the pairing are provided in `info` which indicates
    /// what type of interaction is intended locally.
    ///
    /// Multiple requests can be active at one time for different peers, and
    /// requests can outlive this protocol.  Dropping the request protocol will
    /// automatically reject the pairing.
    ///
    /// All fields will always be present.
    StartRequest {
        payload: PairingDelegate2StartRequestRequest,
        control_handle: PairingDelegate2ControlHandle,
    },
    /// Called when the pairing procedure for a peer has been completed.  This
    /// can be due to successful completion or an error (e.g. due to
    /// cancellation by the peer, a timeout, or disconnection).
    ///
    /// + request `id` The Bluetooth peer ID of the peer which was being paired
    /// + request `success` true if the pairing succeeded, otherwise false
    RequestComplete {
        id: fidl_fuchsia_bluetooth::PeerId,
        success: bool,
        control_handle: PairingDelegate2ControlHandle,
    },
}

impl PairingDelegate2Request {
    #[allow(irrefutable_let_patterns)]
    pub fn into_start_request(
        self,
    ) -> Option<(PairingDelegate2StartRequestRequest, PairingDelegate2ControlHandle)> {
        if let PairingDelegate2Request::StartRequest { payload, control_handle } = self {
            Some((payload, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_request_complete(
        self,
    ) -> Option<(fidl_fuchsia_bluetooth::PeerId, bool, PairingDelegate2ControlHandle)> {
        if let PairingDelegate2Request::RequestComplete { id, success, control_handle } = self {
            Some((id, success, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            PairingDelegate2Request::StartRequest { .. } => "start_request",
            PairingDelegate2Request::RequestComplete { .. } => "request_complete",
        }
    }
}

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

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

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

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

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

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

impl PairingDelegate2ControlHandle {}

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

impl fidl::endpoints::ProtocolMarker for PairingRequestMarker {
    type Proxy = PairingRequestProxy;
    type RequestStream = PairingRequestRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = PairingRequestSynchronousProxy;

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

pub trait PairingRequestProxyInterface: Send + Sync {
    fn r#accept(&self, payload: &PairingRequestAcceptRequest) -> Result<(), fidl::Error>;
    fn r#reject(&self) -> Result<(), fidl::Error>;
    type KeypressResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#keypress(&self, keypress: PairingKeypress) -> Self::KeypressResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct PairingRequestSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for PairingRequestSynchronousProxy {
    type Proxy = PairingRequestProxy;
    type Protocol = PairingRequestMarker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl PairingRequestSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

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

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

    /// Accept the pairing request.
    /// entered_passkey is required if the PairingProperties.passkey_entry
    /// method is used, ignored otherwise.
    pub fn r#accept(&self, mut payload: &PairingRequestAcceptRequest) -> Result<(), fidl::Error> {
        self.client.send::<PairingRequestAcceptRequest>(
            payload,
            0x67278857ae043a5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Reject the pairing request.
    /// Closing this protocol will also reject the pairing request.
    pub fn r#reject(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x550414aec8155cf5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Used to communicate local keypresses to update the remote peer on
    /// the progress of the pairing. The responses to this method should
    /// be used for flow control.
    pub fn r#keypress(
        &self,
        mut keypress: PairingKeypress,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            PairingRequestKeypressRequest,
            fidl::encoding::EmptyPayload,
            PairingRequestMarker,
        >(
            (keypress,),
            0x53948ecc921fbe9b,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for PairingRequestProxy {
    type Protocol = PairingRequestMarker;

    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 PairingRequestProxy {
    /// Create a new Proxy for fuchsia.bluetooth.sys/PairingRequest.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <PairingRequestMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

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

    /// Accept the pairing request.
    /// entered_passkey is required if the PairingProperties.passkey_entry
    /// method is used, ignored otherwise.
    pub fn r#accept(&self, mut payload: &PairingRequestAcceptRequest) -> Result<(), fidl::Error> {
        PairingRequestProxyInterface::r#accept(self, payload)
    }

    /// Reject the pairing request.
    /// Closing this protocol will also reject the pairing request.
    pub fn r#reject(&self) -> Result<(), fidl::Error> {
        PairingRequestProxyInterface::r#reject(self)
    }

    /// Used to communicate local keypresses to update the remote peer on
    /// the progress of the pairing. The responses to this method should
    /// be used for flow control.
    pub fn r#keypress(
        &self,
        mut keypress: PairingKeypress,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        PairingRequestProxyInterface::r#keypress(self, keypress)
    }
}

impl PairingRequestProxyInterface for PairingRequestProxy {
    fn r#accept(&self, mut payload: &PairingRequestAcceptRequest) -> Result<(), fidl::Error> {
        self.client.send::<PairingRequestAcceptRequest>(
            payload,
            0x67278857ae043a5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

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

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

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

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

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

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

#[derive(Debug)]
pub enum PairingRequestEvent {
    OnKeypress { keypress: PairingKeypress },
    OnComplete { success: bool },
}

impl PairingRequestEvent {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_keypress(self) -> Option<PairingKeypress> {
        if let PairingRequestEvent::OnKeypress { keypress } = self {
            Some((keypress))
        } else {
            None
        }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_complete(self) -> Option<bool> {
        if let PairingRequestEvent::OnComplete { success } = self { Some((success)) } else { None }
    }

    /// Decodes a message buffer as a [`PairingRequestEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<PairingRequestEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            0x71a4802e6a5d1aca => {
                let mut out = fidl::new_empty!(
                    PairingRequestOnKeypressRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PairingRequestOnKeypressRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((PairingRequestEvent::OnKeypress { keypress: out.keypress }))
            }
            0xd38d3220987bc79 => {
                let mut out = fidl::new_empty!(
                    PairingRequestOnCompleteRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PairingRequestOnCompleteRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((PairingRequestEvent::OnComplete { success: out.success }))
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name:
                    <PairingRequestMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.bluetooth.sys/PairingRequest.
pub struct PairingRequestRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for PairingRequestRequestStream {
    type Protocol = PairingRequestMarker;
    type ControlHandle = PairingRequestControlHandle;

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x67278857ae043a5 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PairingRequestAcceptRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PairingRequestAcceptRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            PairingRequestControlHandle { inner: this.inner.clone() };
                        Ok(PairingRequestRequest::Accept { payload: req, control_handle })
                    }
                    0x550414aec8155cf5 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            PairingRequestControlHandle { inner: this.inner.clone() };
                        Ok(PairingRequestRequest::Reject { control_handle })
                    }
                    0x53948ecc921fbe9b => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            PairingRequestKeypressRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PairingRequestKeypressRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            PairingRequestControlHandle { inner: this.inner.clone() };
                        Ok(PairingRequestRequest::Keypress {
                            keypress: req.keypress,

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

/// This protocol is active when a pairing is in progress, and provided to the
/// PairingDelegate via the `PairingDelegate.StartRequest`
/// The server will close this protocol with an epitaph if the pairing process
/// completes early without success:
///  - ZX_ERR_UNAVAILABLE - Bluetooth peer has disconnected
///  - ZX_ERR_NOT_SUPPORTED - a passkey was provided when it was not expected
///  - ZX_ERR_BAD_STATE - a keypress was sent when not using
///                       PairingProperties.passkey_entry
///  - ZX_ERR_TIMED_OUT - no activity was detected, and the pairing was stopped
#[derive(Debug)]
pub enum PairingRequestRequest {
    /// Accept the pairing request.
    /// entered_passkey is required if the PairingProperties.passkey_entry
    /// method is used, ignored otherwise.
    Accept { payload: PairingRequestAcceptRequest, control_handle: PairingRequestControlHandle },
    /// Reject the pairing request.
    /// Closing this protocol will also reject the pairing request.
    Reject { control_handle: PairingRequestControlHandle },
    /// Used to communicate local keypresses to update the remote peer on
    /// the progress of the pairing. The responses to this method should
    /// be used for flow control.
    Keypress { keypress: PairingKeypress, responder: PairingRequestKeypressResponder },
}

impl PairingRequestRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_accept(self) -> Option<(PairingRequestAcceptRequest, PairingRequestControlHandle)> {
        if let PairingRequestRequest::Accept { payload, control_handle } = self {
            Some((payload, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_reject(self) -> Option<(PairingRequestControlHandle)> {
        if let PairingRequestRequest::Reject { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_keypress(self) -> Option<(PairingKeypress, PairingRequestKeypressResponder)> {
        if let PairingRequestRequest::Keypress { keypress, responder } = self {
            Some((keypress, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            PairingRequestRequest::Accept { .. } => "accept",
            PairingRequestRequest::Reject { .. } => "reject",
            PairingRequestRequest::Keypress { .. } => "keypress",
        }
    }
}

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

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

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

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

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

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

impl PairingRequestControlHandle {
    pub fn send_on_keypress(&self, mut keypress: PairingKeypress) -> Result<(), fidl::Error> {
        self.inner.send::<PairingRequestOnKeypressRequest>(
            (keypress,),
            0,
            0x71a4802e6a5d1aca,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_on_complete(&self, mut success: bool) -> Result<(), fidl::Error> {
        self.inner.send::<PairingRequestOnCompleteRequest>(
            (success,),
            0,
            0xd38d3220987bc79,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for ProcedureTokenMarker {
    type Proxy = ProcedureTokenProxy;
    type RequestStream = ProcedureTokenRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ProcedureTokenSynchronousProxy;

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

pub trait ProcedureTokenProxyInterface: Send + Sync {}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ProcedureTokenSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ProcedureTokenSynchronousProxy {
    type Proxy = ProcedureTokenProxy;
    type Protocol = ProcedureTokenMarker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl ProcedureTokenSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

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

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

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

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

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

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

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

impl fidl::endpoints::Proxy for ProcedureTokenProxy {
    type Protocol = ProcedureTokenMarker;

    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 ProcedureTokenProxy {
    /// Create a new Proxy for fuchsia.bluetooth.sys/ProcedureToken.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <ProcedureTokenMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

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

impl ProcedureTokenProxyInterface for ProcedureTokenProxy {}

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

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.bluetooth.sys/ProcedureToken.
pub struct ProcedureTokenRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for ProcedureTokenRequestStream {
    type Protocol = ProcedureTokenMarker;
    type ControlHandle = ProcedureTokenControlHandle;

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <ProcedureTokenMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Represents an active procedure. The validity of a handle that supports this protocol is tied to
/// the activity of the procedure that it is attached to. To elaborate:
///
///   1. Closing a token handle ends the procedure that it is attached to.
///   2. The system closes a token handle to communicate that a procedure was internally terminated.
#[derive(Debug)]
pub enum ProcedureTokenRequest {}

impl ProcedureTokenRequest {
    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {}
    }
}

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

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

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

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

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

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

impl ProcedureTokenControlHandle {}

mod internal {
    use super::*;

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

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for AccessMakeDiscoverableRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                token: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ProcedureTokenMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

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

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for AccessSetPairingDelegateRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                input: fidl::new_empty!(
                    InputCapability,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                output: fidl::new_empty!(
                    OutputCapability,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                delegate: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<PairingDelegateMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

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

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for AccessStartDiscoveryRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                token: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ProcedureTokenMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

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

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for PairingSetDelegateRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                input: fidl::new_empty!(
                    InputCapability,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                output: fidl::new_empty!(
                    OutputCapability,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                delegate: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<PairingDelegate2Marker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

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

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for PairingSetPairingDelegateRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                input: fidl::new_empty!(
                    InputCapability,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                output: fidl::new_empty!(
                    OutputCapability,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                delegate: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<PairingDelegateMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

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

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

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

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

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

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

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

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

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

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

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

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

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

            next_offset += envelope_size;

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

            Ok(())
        }
    }

    impl PairingDelegate2StartRequestRequest {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.request {
                return 3;
            }
            if let Some(_) = self.info {
                return 2;
            }
            if let Some(_) = self.peer {
                return 1;
            }
            0
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

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

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

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

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

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

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

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

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

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

            next_offset += envelope_size;

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

            Ok(())
        }
    }
}