fidl_fuchsia_bluetooth_gatt/

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ClientConnectToServiceRequest {
    pub id: u64,
    pub service: fidl::endpoints::ServerEnd<RemoteServiceMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ServerPublishServiceRequest {
    pub info: ServiceInfo,
    pub delegate: fidl::endpoints::ClientEnd<LocalServiceDelegateMarker>,
    pub service: fidl::endpoints::ServerEnd<LocalServiceMarker>,
}

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

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

impl fidl::endpoints::ProtocolMarker for ClientMarker {
    type Proxy = ClientProxy;
    type RequestStream = ClientRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ClientSynchronousProxy;

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

pub trait ClientProxyInterface: Send + Sync {
    type ListServicesResponseFut: std::future::Future<
            Output = Result<(fidl_fuchsia_bluetooth::Status, Vec<ServiceInfo>), fidl::Error>,
        > + Send;
    fn r#list_services(&self, uuids: Option<&[String]>) -> Self::ListServicesResponseFut;
    fn r#connect_to_service(
        &self,
        id: u64,
        service: fidl::endpoints::ServerEnd<RemoteServiceMarker>,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ClientSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ClientSynchronousProxy {
    type Proxy = ClientProxy;
    type Protocol = ClientMarker;

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

    /// Enumerates services found on the peer that this Client represents. Results
    /// can be restricted by specifying a list of UUIDs in `uuids`. The returned
    /// ServiceInfo structures will contain only basic information about each
    /// service and the `characteristics` and `includes` fields will be null.
    ///
    /// To further interact with services, clients must obtain a RemoteService
    /// handle by calling ConnectToService().
    pub fn r#list_services(
        &self,
        mut uuids: Option<&[String]>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(fidl_fuchsia_bluetooth::Status, Vec<ServiceInfo>), fidl::Error> {
        let _response = self
            .client
            .send_query::<ClientListServicesRequest, ClientListServicesResponse, ClientMarker>(
                (uuids,),
                0x367b6c1e1540fb99,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok((_response.status, _response.services))
    }

    /// Connects the RemoteService with the given identifier.
    pub fn r#connect_to_service(
        &self,
        mut id: u64,
        mut service: fidl::endpoints::ServerEnd<RemoteServiceMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<ClientConnectToServiceRequest>(
            (id, service),
            0x45ca1666a35cd25,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for ClientProxy {
    type Protocol = ClientMarker;

    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 ClientProxy {
    /// Create a new Proxy for fuchsia.bluetooth.gatt/Client.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <ClientMarker 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) -> ClientEventStream {
        ClientEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Enumerates services found on the peer that this Client represents. Results
    /// can be restricted by specifying a list of UUIDs in `uuids`. The returned
    /// ServiceInfo structures will contain only basic information about each
    /// service and the `characteristics` and `includes` fields will be null.
    ///
    /// To further interact with services, clients must obtain a RemoteService
    /// handle by calling ConnectToService().
    pub fn r#list_services(
        &self,
        mut uuids: Option<&[String]>,
    ) -> fidl::client::QueryResponseFut<
        (fidl_fuchsia_bluetooth::Status, Vec<ServiceInfo>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ClientProxyInterface::r#list_services(self, uuids)
    }

    /// Connects the RemoteService with the given identifier.
    pub fn r#connect_to_service(
        &self,
        mut id: u64,
        mut service: fidl::endpoints::ServerEnd<RemoteServiceMarker>,
    ) -> Result<(), fidl::Error> {
        ClientProxyInterface::r#connect_to_service(self, id, service)
    }
}

impl ClientProxyInterface for ClientProxy {
    type ListServicesResponseFut = fidl::client::QueryResponseFut<
        (fidl_fuchsia_bluetooth::Status, Vec<ServiceInfo>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#list_services(&self, mut uuids: Option<&[String]>) -> Self::ListServicesResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(fidl_fuchsia_bluetooth::Status, Vec<ServiceInfo>), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ClientListServicesResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x367b6c1e1540fb99,
            >(_buf?)?;
            Ok((_response.status, _response.services))
        }
        self.client.send_query_and_decode::<
            ClientListServicesRequest,
            (fidl_fuchsia_bluetooth::Status, Vec<ServiceInfo>),
        >(
            (uuids,),
            0x367b6c1e1540fb99,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#connect_to_service(
        &self,
        mut id: u64,
        mut service: fidl::endpoints::ServerEnd<RemoteServiceMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<ClientConnectToServiceRequest>(
            (id, service),
            0x45ca1666a35cd25,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for ClientRequestStream {
    type Protocol = ClientMarker;
    type ControlHandle = ClientControlHandle;

    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 {
        ClientControlHandle { 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 ClientRequestStream {
    type Item = Result<ClientRequest, 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 ClientRequestStream 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 {
                    0x367b6c1e1540fb99 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ClientListServicesRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ClientListServicesRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ClientControlHandle { inner: this.inner.clone() };
                        Ok(ClientRequest::ListServices {
                            uuids: req.uuids,

                            responder: ClientListServicesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x45ca1666a35cd25 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            ClientConnectToServiceRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ClientConnectToServiceRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ClientControlHandle { inner: this.inner.clone() };
                        Ok(ClientRequest::ConnectToService {
                            id: req.id,
                            service: req.service,

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

#[derive(Debug)]
pub enum ClientRequest {
    /// Enumerates services found on the peer that this Client represents. Results
    /// can be restricted by specifying a list of UUIDs in `uuids`. The returned
    /// ServiceInfo structures will contain only basic information about each
    /// service and the `characteristics` and `includes` fields will be null.
    ///
    /// To further interact with services, clients must obtain a RemoteService
    /// handle by calling ConnectToService().
    ListServices { uuids: Option<Vec<String>>, responder: ClientListServicesResponder },
    /// Connects the RemoteService with the given identifier.
    ConnectToService {
        id: u64,
        service: fidl::endpoints::ServerEnd<RemoteServiceMarker>,
        control_handle: ClientControlHandle,
    },
}

impl ClientRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_list_services(self) -> Option<(Option<Vec<String>>, ClientListServicesResponder)> {
        if let ClientRequest::ListServices { uuids, responder } = self {
            Some((uuids, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_connect_to_service(
        self,
    ) -> Option<(u64, fidl::endpoints::ServerEnd<RemoteServiceMarker>, ClientControlHandle)> {
        if let ClientRequest::ConnectToService { id, service, control_handle } = self {
            Some((id, service, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            ClientRequest::ListServices { .. } => "list_services",
            ClientRequest::ConnectToService { .. } => "connect_to_service",
        }
    }
}

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

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

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

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

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

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

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

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

    fn send_raw(
        &self,
        mut status: &fidl_fuchsia_bluetooth::Status,
        mut services: &[ServiceInfo],
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<ClientListServicesResponse>(
            (status, services),
            self.tx_id,
            0x367b6c1e1540fb99,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for LocalServiceMarker {
    type Proxy = LocalServiceProxy;
    type RequestStream = LocalServiceRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = LocalServiceSynchronousProxy;

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

pub trait LocalServiceProxyInterface: Send + Sync {
    fn r#remove_service(&self) -> Result<(), fidl::Error>;
    fn r#notify_value(
        &self,
        characteristic_id: u64,
        peer_id: &str,
        value: &[u8],
        confirm: bool,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct LocalServiceSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for LocalServiceSynchronousProxy {
    type Proxy = LocalServiceProxy;
    type Protocol = LocalServiceMarker;

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

    /// Removes the service that this interface instance corresponds to. Does
    /// nothing if the service is already removed.
    pub fn r#remove_service(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x53c92ea8871606f1,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Sends a notification carrying the `value` of the characteristic with the
    /// given `characteristic_id` to the device with `peer_id`.
    ///
    /// If `confirm` is true, then this method sends an indication instead. If the
    /// peer fails to confirm the indication, the link between the peer and the
    /// local adapter will be closed.
    ///
    /// This method has no effect if the peer has not enabled notifications or
    /// indications on the requested characteristic.
    pub fn r#notify_value(
        &self,
        mut characteristic_id: u64,
        mut peer_id: &str,
        mut value: &[u8],
        mut confirm: bool,
    ) -> Result<(), fidl::Error> {
        self.client.send::<LocalServiceNotifyValueRequest>(
            (characteristic_id, peer_id, value, confirm),
            0x5bb142dfdd6d1fa9,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for LocalServiceProxy {
    type Protocol = LocalServiceMarker;

    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 LocalServiceProxy {
    /// Create a new Proxy for fuchsia.bluetooth.gatt/LocalService.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <LocalServiceMarker 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) -> LocalServiceEventStream {
        LocalServiceEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Removes the service that this interface instance corresponds to. Does
    /// nothing if the service is already removed.
    pub fn r#remove_service(&self) -> Result<(), fidl::Error> {
        LocalServiceProxyInterface::r#remove_service(self)
    }

    /// Sends a notification carrying the `value` of the characteristic with the
    /// given `characteristic_id` to the device with `peer_id`.
    ///
    /// If `confirm` is true, then this method sends an indication instead. If the
    /// peer fails to confirm the indication, the link between the peer and the
    /// local adapter will be closed.
    ///
    /// This method has no effect if the peer has not enabled notifications or
    /// indications on the requested characteristic.
    pub fn r#notify_value(
        &self,
        mut characteristic_id: u64,
        mut peer_id: &str,
        mut value: &[u8],
        mut confirm: bool,
    ) -> Result<(), fidl::Error> {
        LocalServiceProxyInterface::r#notify_value(self, characteristic_id, peer_id, value, confirm)
    }
}

impl LocalServiceProxyInterface for LocalServiceProxy {
    fn r#remove_service(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x53c92ea8871606f1,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#notify_value(
        &self,
        mut characteristic_id: u64,
        mut peer_id: &str,
        mut value: &[u8],
        mut confirm: bool,
    ) -> Result<(), fidl::Error> {
        self.client.send::<LocalServiceNotifyValueRequest>(
            (characteristic_id, peer_id, value, confirm),
            0x5bb142dfdd6d1fa9,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for LocalServiceRequestStream {
    type Protocol = LocalServiceMarker;
    type ControlHandle = LocalServiceControlHandle;

    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 {
        LocalServiceControlHandle { 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 LocalServiceRequestStream {
    type Item = Result<LocalServiceRequest, 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 LocalServiceRequestStream 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 {
                    0x53c92ea8871606f1 => {
                        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 =
                            LocalServiceControlHandle { inner: this.inner.clone() };
                        Ok(LocalServiceRequest::RemoveService { control_handle })
                    }
                    0x5bb142dfdd6d1fa9 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            LocalServiceNotifyValueRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<LocalServiceNotifyValueRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            LocalServiceControlHandle { inner: this.inner.clone() };
                        Ok(LocalServiceRequest::NotifyValue {
                            characteristic_id: req.characteristic_id,
                            peer_id: req.peer_id,
                            value: req.value,
                            confirm: req.confirm,

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

/// Interface for communicating with a published service.
#[derive(Debug)]
pub enum LocalServiceRequest {
    /// Removes the service that this interface instance corresponds to. Does
    /// nothing if the service is already removed.
    RemoveService { control_handle: LocalServiceControlHandle },
    /// Sends a notification carrying the `value` of the characteristic with the
    /// given `characteristic_id` to the device with `peer_id`.
    ///
    /// If `confirm` is true, then this method sends an indication instead. If the
    /// peer fails to confirm the indication, the link between the peer and the
    /// local adapter will be closed.
    ///
    /// This method has no effect if the peer has not enabled notifications or
    /// indications on the requested characteristic.
    NotifyValue {
        characteristic_id: u64,
        peer_id: String,
        value: Vec<u8>,
        confirm: bool,
        control_handle: LocalServiceControlHandle,
    },
}

impl LocalServiceRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_remove_service(self) -> Option<(LocalServiceControlHandle)> {
        if let LocalServiceRequest::RemoveService { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_notify_value(
        self,
    ) -> Option<(u64, String, Vec<u8>, bool, LocalServiceControlHandle)> {
        if let LocalServiceRequest::NotifyValue {
            characteristic_id,
            peer_id,
            value,
            confirm,
            control_handle,
        } = self
        {
            Some((characteristic_id, peer_id, value, confirm, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            LocalServiceRequest::RemoveService { .. } => "remove_service",
            LocalServiceRequest::NotifyValue { .. } => "notify_value",
        }
    }
}

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for LocalServiceDelegateMarker {
    type Proxy = LocalServiceDelegateProxy;
    type RequestStream = LocalServiceDelegateRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = LocalServiceDelegateSynchronousProxy;

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

pub trait LocalServiceDelegateProxyInterface: Send + Sync {
    fn r#on_characteristic_configuration(
        &self,
        characteristic_id: u64,
        peer_id: &str,
        notify: bool,
        indicate: bool,
    ) -> Result<(), fidl::Error>;
    type OnReadValueResponseFut: std::future::Future<Output = Result<(Option<Vec<u8>>, ErrorCode), fidl::Error>>
        + Send;
    fn r#on_read_value(&self, id: u64, offset: i32) -> Self::OnReadValueResponseFut;
    type OnWriteValueResponseFut: std::future::Future<Output = Result<ErrorCode, fidl::Error>>
        + Send;
    fn r#on_write_value(&self, id: u64, offset: u16, value: &[u8])
    -> Self::OnWriteValueResponseFut;
    fn r#on_write_without_response(
        &self,
        id: u64,
        offset: u16,
        value: &[u8],
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct LocalServiceDelegateSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for LocalServiceDelegateSynchronousProxy {
    type Proxy = LocalServiceDelegateProxy;
    type Protocol = LocalServiceDelegateMarker;

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

    /// Notifies the delegate when a remote device with `peer_id` enables or
    /// disables notifications or indications on the characteristic with the given
    /// `characteristic_id`.
    pub fn r#on_characteristic_configuration(
        &self,
        mut characteristic_id: u64,
        mut peer_id: &str,
        mut notify: bool,
        mut indicate: bool,
    ) -> Result<(), fidl::Error> {
        self.client.send::<LocalServiceDelegateOnCharacteristicConfigurationRequest>(
            (characteristic_id, peer_id, notify, indicate),
            0x71384022749a6e90,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Called when a remote device issues a request to read the value of the
    /// of the characteristic or descriptor with given identifier. The delegate
    /// must respond to the request by returning the characteristic value. If the
    /// read request resulted in an error it should be returned in `error_code`.
    /// On success, `error_code` should be set to NO_ERROR and a `value` should be
    /// provided.
    pub fn r#on_read_value(
        &self,
        mut id: u64,
        mut offset: i32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(Option<Vec<u8>>, ErrorCode), fidl::Error> {
        let _response = self.client.send_query::<
            LocalServiceDelegateOnReadValueRequest,
            LocalServiceDelegateOnReadValueResponse,
            LocalServiceDelegateMarker,
        >(
            (id, offset,),
            0x2f11da4cc774629,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok((_response.value, _response.status))
    }

    /// Called when a remote device issues a request to write the value of the
    /// characteristic or descriptor with the given identifier.
    pub fn r#on_write_value(
        &self,
        mut id: u64,
        mut offset: u16,
        mut value: &[u8],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ErrorCode, fidl::Error> {
        let _response = self.client.send_query::<
            LocalServiceDelegateOnWriteValueRequest,
            LocalServiceDelegateOnWriteValueResponse,
            LocalServiceDelegateMarker,
        >(
            (id, offset, value,),
            0x2869075d462d3ea5,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.status)
    }

    /// Called when a remote device issues a request to write the value of the
    /// characteristic with the given identifier. This can be called on a
    /// characteristic with the WRITE_WITHOUT_RESPONSE property.
    pub fn r#on_write_without_response(
        &self,
        mut id: u64,
        mut offset: u16,
        mut value: &[u8],
    ) -> Result<(), fidl::Error> {
        self.client.send::<LocalServiceDelegateOnWriteWithoutResponseRequest>(
            (id, offset, value),
            0x66ec30d296fd8d64,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for LocalServiceDelegateProxy {
    type Protocol = LocalServiceDelegateMarker;

    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 LocalServiceDelegateProxy {
    /// Create a new Proxy for fuchsia.bluetooth.gatt/LocalServiceDelegate.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <LocalServiceDelegateMarker 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) -> LocalServiceDelegateEventStream {
        LocalServiceDelegateEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Notifies the delegate when a remote device with `peer_id` enables or
    /// disables notifications or indications on the characteristic with the given
    /// `characteristic_id`.
    pub fn r#on_characteristic_configuration(
        &self,
        mut characteristic_id: u64,
        mut peer_id: &str,
        mut notify: bool,
        mut indicate: bool,
    ) -> Result<(), fidl::Error> {
        LocalServiceDelegateProxyInterface::r#on_characteristic_configuration(
            self,
            characteristic_id,
            peer_id,
            notify,
            indicate,
        )
    }

    /// Called when a remote device issues a request to read the value of the
    /// of the characteristic or descriptor with given identifier. The delegate
    /// must respond to the request by returning the characteristic value. If the
    /// read request resulted in an error it should be returned in `error_code`.
    /// On success, `error_code` should be set to NO_ERROR and a `value` should be
    /// provided.
    pub fn r#on_read_value(
        &self,
        mut id: u64,
        mut offset: i32,
    ) -> fidl::client::QueryResponseFut<
        (Option<Vec<u8>>, ErrorCode),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        LocalServiceDelegateProxyInterface::r#on_read_value(self, id, offset)
    }

    /// Called when a remote device issues a request to write the value of the
    /// characteristic or descriptor with the given identifier.
    pub fn r#on_write_value(
        &self,
        mut id: u64,
        mut offset: u16,
        mut value: &[u8],
    ) -> fidl::client::QueryResponseFut<ErrorCode, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        LocalServiceDelegateProxyInterface::r#on_write_value(self, id, offset, value)
    }

    /// Called when a remote device issues a request to write the value of the
    /// characteristic with the given identifier. This can be called on a
    /// characteristic with the WRITE_WITHOUT_RESPONSE property.
    pub fn r#on_write_without_response(
        &self,
        mut id: u64,
        mut offset: u16,
        mut value: &[u8],
    ) -> Result<(), fidl::Error> {
        LocalServiceDelegateProxyInterface::r#on_write_without_response(self, id, offset, value)
    }
}

impl LocalServiceDelegateProxyInterface for LocalServiceDelegateProxy {
    fn r#on_characteristic_configuration(
        &self,
        mut characteristic_id: u64,
        mut peer_id: &str,
        mut notify: bool,
        mut indicate: bool,
    ) -> Result<(), fidl::Error> {
        self.client.send::<LocalServiceDelegateOnCharacteristicConfigurationRequest>(
            (characteristic_id, peer_id, notify, indicate),
            0x71384022749a6e90,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type OnReadValueResponseFut = fidl::client::QueryResponseFut<
        (Option<Vec<u8>>, ErrorCode),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#on_read_value(&self, mut id: u64, mut offset: i32) -> Self::OnReadValueResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(Option<Vec<u8>>, ErrorCode), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                LocalServiceDelegateOnReadValueResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2f11da4cc774629,
            >(_buf?)?;
            Ok((_response.value, _response.status))
        }
        self.client.send_query_and_decode::<
            LocalServiceDelegateOnReadValueRequest,
            (Option<Vec<u8>>, ErrorCode),
        >(
            (id, offset,),
            0x2f11da4cc774629,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type OnWriteValueResponseFut =
        fidl::client::QueryResponseFut<ErrorCode, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#on_write_value(
        &self,
        mut id: u64,
        mut offset: u16,
        mut value: &[u8],
    ) -> Self::OnWriteValueResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ErrorCode, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                LocalServiceDelegateOnWriteValueResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2869075d462d3ea5,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<LocalServiceDelegateOnWriteValueRequest, ErrorCode>(
            (id, offset, value),
            0x2869075d462d3ea5,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#on_write_without_response(
        &self,
        mut id: u64,
        mut offset: u16,
        mut value: &[u8],
    ) -> Result<(), fidl::Error> {
        self.client.send::<LocalServiceDelegateOnWriteWithoutResponseRequest>(
            (id, offset, value),
            0x66ec30d296fd8d64,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for LocalServiceDelegateRequestStream {
    type Protocol = LocalServiceDelegateMarker;
    type ControlHandle = LocalServiceDelegateControlHandle;

    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 {
        LocalServiceDelegateControlHandle { 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 LocalServiceDelegateRequestStream {
    type Item = Result<LocalServiceDelegateRequest, 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 LocalServiceDelegateRequestStream 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 {
                0x71384022749a6e90 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(LocalServiceDelegateOnCharacteristicConfigurationRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<LocalServiceDelegateOnCharacteristicConfigurationRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = LocalServiceDelegateControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(LocalServiceDelegateRequest::OnCharacteristicConfiguration {characteristic_id: req.characteristic_id,
peer_id: req.peer_id,
notify: req.notify,
indicate: req.indicate,

                        control_handle,
                    })
                }
                0x2f11da4cc774629 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(LocalServiceDelegateOnReadValueRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<LocalServiceDelegateOnReadValueRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = LocalServiceDelegateControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(LocalServiceDelegateRequest::OnReadValue {id: req.id,
offset: req.offset,

                        responder: LocalServiceDelegateOnReadValueResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x2869075d462d3ea5 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(LocalServiceDelegateOnWriteValueRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<LocalServiceDelegateOnWriteValueRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = LocalServiceDelegateControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(LocalServiceDelegateRequest::OnWriteValue {id: req.id,
offset: req.offset,
value: req.value,

                        responder: LocalServiceDelegateOnWriteValueResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x66ec30d296fd8d64 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(LocalServiceDelegateOnWriteWithoutResponseRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<LocalServiceDelegateOnWriteWithoutResponseRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = LocalServiceDelegateControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(LocalServiceDelegateRequest::OnWriteWithoutResponse {id: req.id,
offset: req.offset,
value: req.value,

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

/// Interface for responding to requests on a local service.
#[derive(Debug)]
pub enum LocalServiceDelegateRequest {
    /// Notifies the delegate when a remote device with `peer_id` enables or
    /// disables notifications or indications on the characteristic with the given
    /// `characteristic_id`.
    OnCharacteristicConfiguration {
        characteristic_id: u64,
        peer_id: String,
        notify: bool,
        indicate: bool,
        control_handle: LocalServiceDelegateControlHandle,
    },
    /// Called when a remote device issues a request to read the value of the
    /// of the characteristic or descriptor with given identifier. The delegate
    /// must respond to the request by returning the characteristic value. If the
    /// read request resulted in an error it should be returned in `error_code`.
    /// On success, `error_code` should be set to NO_ERROR and a `value` should be
    /// provided.
    OnReadValue { id: u64, offset: i32, responder: LocalServiceDelegateOnReadValueResponder },
    /// Called when a remote device issues a request to write the value of the
    /// characteristic or descriptor with the given identifier.
    OnWriteValue {
        id: u64,
        offset: u16,
        value: Vec<u8>,
        responder: LocalServiceDelegateOnWriteValueResponder,
    },
    /// Called when a remote device issues a request to write the value of the
    /// characteristic with the given identifier. This can be called on a
    /// characteristic with the WRITE_WITHOUT_RESPONSE property.
    OnWriteWithoutResponse {
        id: u64,
        offset: u16,
        value: Vec<u8>,
        control_handle: LocalServiceDelegateControlHandle,
    },
}

impl LocalServiceDelegateRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_characteristic_configuration(
        self,
    ) -> Option<(u64, String, bool, bool, LocalServiceDelegateControlHandle)> {
        if let LocalServiceDelegateRequest::OnCharacteristicConfiguration {
            characteristic_id,
            peer_id,
            notify,
            indicate,
            control_handle,
        } = self
        {
            Some((characteristic_id, peer_id, notify, indicate, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_on_read_value(
        self,
    ) -> Option<(u64, i32, LocalServiceDelegateOnReadValueResponder)> {
        if let LocalServiceDelegateRequest::OnReadValue { id, offset, responder } = self {
            Some((id, offset, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_on_write_value(
        self,
    ) -> Option<(u64, u16, Vec<u8>, LocalServiceDelegateOnWriteValueResponder)> {
        if let LocalServiceDelegateRequest::OnWriteValue { id, offset, value, responder } = self {
            Some((id, offset, value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_on_write_without_response(
        self,
    ) -> Option<(u64, u16, Vec<u8>, LocalServiceDelegateControlHandle)> {
        if let LocalServiceDelegateRequest::OnWriteWithoutResponse {
            id,
            offset,
            value,
            control_handle,
        } = self
        {
            Some((id, offset, value, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            LocalServiceDelegateRequest::OnCharacteristicConfiguration { .. } => {
                "on_characteristic_configuration"
            }
            LocalServiceDelegateRequest::OnReadValue { .. } => "on_read_value",
            LocalServiceDelegateRequest::OnWriteValue { .. } => "on_write_value",
            LocalServiceDelegateRequest::OnWriteWithoutResponse { .. } => {
                "on_write_without_response"
            }
        }
    }
}

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut value: Option<&[u8]>, mut status: ErrorCode) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<LocalServiceDelegateOnReadValueResponse>(
            (value, status),
            self.tx_id,
            0x2f11da4cc774629,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for RemoteServiceMarker {
    type Proxy = RemoteServiceProxy;
    type RequestStream = RemoteServiceRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = RemoteServiceSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) RemoteService";
}
pub type RemoteServiceReadByTypeResult = Result<Vec<ReadByTypeResult>, Error>;

pub trait RemoteServiceProxyInterface: Send + Sync {
    type DiscoverCharacteristicsResponseFut: std::future::Future<
            Output = Result<(fidl_fuchsia_bluetooth::Status, Vec<Characteristic>), fidl::Error>,
        > + Send;
    fn r#discover_characteristics(&self) -> Self::DiscoverCharacteristicsResponseFut;
    type ReadCharacteristicResponseFut: std::future::Future<Output = Result<(fidl_fuchsia_bluetooth::Status, Vec<u8>), fidl::Error>>
        + Send;
    fn r#read_characteristic(&self, id: u64) -> Self::ReadCharacteristicResponseFut;
    type ReadLongCharacteristicResponseFut: std::future::Future<Output = Result<(fidl_fuchsia_bluetooth::Status, Vec<u8>), fidl::Error>>
        + Send;
    fn r#read_long_characteristic(
        &self,
        id: u64,
        offset: u16,
        max_bytes: u16,
    ) -> Self::ReadLongCharacteristicResponseFut;
    type WriteCharacteristicResponseFut: std::future::Future<Output = Result<fidl_fuchsia_bluetooth::Status, fidl::Error>>
        + Send;
    fn r#write_characteristic(&self, id: u64, value: &[u8])
    -> Self::WriteCharacteristicResponseFut;
    type WriteLongCharacteristicResponseFut: std::future::Future<Output = Result<fidl_fuchsia_bluetooth::Status, fidl::Error>>
        + Send;
    fn r#write_long_characteristic(
        &self,
        id: u64,
        offset: u16,
        value: &[u8],
        write_options: &WriteOptions,
    ) -> Self::WriteLongCharacteristicResponseFut;
    fn r#write_characteristic_without_response(
        &self,
        id: u64,
        value: &[u8],
    ) -> Result<(), fidl::Error>;
    type ReadDescriptorResponseFut: std::future::Future<Output = Result<(fidl_fuchsia_bluetooth::Status, Vec<u8>), fidl::Error>>
        + Send;
    fn r#read_descriptor(&self, id: u64) -> Self::ReadDescriptorResponseFut;
    type ReadLongDescriptorResponseFut: std::future::Future<Output = Result<(fidl_fuchsia_bluetooth::Status, Vec<u8>), fidl::Error>>
        + Send;
    fn r#read_long_descriptor(
        &self,
        id: u64,
        offset: u16,
        max_bytes: u16,
    ) -> Self::ReadLongDescriptorResponseFut;
    type WriteDescriptorResponseFut: std::future::Future<Output = Result<fidl_fuchsia_bluetooth::Status, fidl::Error>>
        + Send;
    fn r#write_descriptor(&self, id: u64, value: &[u8]) -> Self::WriteDescriptorResponseFut;
    type WriteLongDescriptorResponseFut: std::future::Future<Output = Result<fidl_fuchsia_bluetooth::Status, fidl::Error>>
        + Send;
    fn r#write_long_descriptor(
        &self,
        id: u64,
        offset: u16,
        value: &[u8],
    ) -> Self::WriteLongDescriptorResponseFut;
    type ReadByTypeResponseFut: std::future::Future<Output = Result<RemoteServiceReadByTypeResult, fidl::Error>>
        + Send;
    fn r#read_by_type(&self, uuid: &fidl_fuchsia_bluetooth::Uuid) -> Self::ReadByTypeResponseFut;
    type NotifyCharacteristicResponseFut: std::future::Future<Output = Result<fidl_fuchsia_bluetooth::Status, fidl::Error>>
        + Send;
    fn r#notify_characteristic(
        &self,
        id: u64,
        enable: bool,
    ) -> Self::NotifyCharacteristicResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct RemoteServiceSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for RemoteServiceSynchronousProxy {
    type Proxy = RemoteServiceProxy;
    type Protocol = RemoteServiceMarker;

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

    /// Returns the characteristics and characteristic descriptors that belong to
    /// this service.
    pub fn r#discover_characteristics(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(fidl_fuchsia_bluetooth::Status, Vec<Characteristic>), fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            RemoteServiceDiscoverCharacteristicsResponse,
            RemoteServiceMarker,
        >(
            (),
            0x4c13b72543a8aa16,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok((_response.status, _response.characteristics))
    }

    /// Reads the value of the characteristic with `id` and returns it in the
    /// reply. If `status` indicates an error `value` will be empty.
    ///
    /// If the characteristic has a long value (i.e. larger than the current MTU)
    /// this method will return only the first (MTU - 1) bytes of the value. Use
    /// ReadLongCharacteristic() to read larger values or starting at a non-zero
    /// offset.
    pub fn r#read_characteristic(
        &self,
        mut id: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(fidl_fuchsia_bluetooth::Status, Vec<u8>), fidl::Error> {
        let _response = self.client.send_query::<
            RemoteServiceReadCharacteristicRequest,
            RemoteServiceReadCharacteristicResponse,
            RemoteServiceMarker,
        >(
            (id,),
            0x200a5253bc0771c8,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok((_response.status, _response.value))
    }

    /// Reads the complete value of a characteristic with the given `id`. This
    /// procedure should be used if the characteristic is known to have a value
    /// that can not be read in a single request.
    ///
    /// Returns up to `max_bytes` octets of the characteristic value starting at
    /// the given `offset`.
    ///
    /// This may return an error if:
    ///   a. `max_bytes` is 0;
    ///   b. The `offset` is invalid;
    ///   c. The characteristic does not have a long value;
    ///   d. The server does not support the long read procedure.
    pub fn r#read_long_characteristic(
        &self,
        mut id: u64,
        mut offset: u16,
        mut max_bytes: u16,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(fidl_fuchsia_bluetooth::Status, Vec<u8>), fidl::Error> {
        let _response = self.client.send_query::<
            RemoteServiceReadLongCharacteristicRequest,
            RemoteServiceReadLongCharacteristicResponse,
            RemoteServiceMarker,
        >(
            (id, offset, max_bytes,),
            0x2df2f20845555766,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok((_response.status, _response.value))
    }

    /// Writes `value` to the characteristic with `id`. This operation may return
    /// an error if:
    ///   a. The size of `value` exceeds the current MTU.
    ///   b. The characteristic referred to by `id` does not have the 'write'
    ///      property.
    pub fn r#write_characteristic(
        &self,
        mut id: u64,
        mut value: &[u8],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<fidl_fuchsia_bluetooth::Status, fidl::Error> {
        let _response = self.client.send_query::<
            RemoteServiceWriteCharacteristicRequest,
            RemoteServiceWriteCharacteristicResponse,
            RemoteServiceMarker,
        >(
            (id, value,),
            0x5c1f529653cdad04,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.status)
    }

    /// Writes `value` to the characteristic with `id`, beginning at `offset` using
    /// the provided `write_options`.
    ///
    /// This procedure should be used if the value to be written is too long to
    /// fit in a single request or needs to be written at an offset. This may
    /// return an error if:
    ///   a. The `offset` is invalid;
    ///   b. The server does not support the long write procedure.
    ///
    /// Long Writes require multiple messages to the remote service and take longer
    /// to execute than Short Writes. It is not recommended to send a short write
    /// while a long write is in process to the same id and data range. The order
    /// of the responses from this function signify the order in which the remote
    /// service received them, not necessarily the order in which it is called.
    pub fn r#write_long_characteristic(
        &self,
        mut id: u64,
        mut offset: u16,
        mut value: &[u8],
        mut write_options: &WriteOptions,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<fidl_fuchsia_bluetooth::Status, fidl::Error> {
        let _response = self.client.send_query::<
            RemoteServiceWriteLongCharacteristicRequest,
            RemoteServiceWriteLongCharacteristicResponse,
            RemoteServiceMarker,
        >(
            (id, offset, value, write_options,),
            0x2d358800658043e1,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.status)
    }

    /// Writes `value` to the characteristic with `id` without soliciting an
    /// acknowledgement from the peer. This method has no response and its delivery
    /// cannot be confirmed.
    pub fn r#write_characteristic_without_response(
        &self,
        mut id: u64,
        mut value: &[u8],
    ) -> Result<(), fidl::Error> {
        self.client.send::<RemoteServiceWriteCharacteristicWithoutResponseRequest>(
            (id, value),
            0x6eee4a248275f56e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Reads the value of the characteristic descriptor with `id` and returns it
    /// in the reply. If `status` indicates an error, `value` can be ignored.
    ///
    /// If the descriptor has a long value (i.e. larger than the current MTU)
    /// this method will return only the first (MTU - 1) bytes of the value. Use
    /// ReadLongDescriptor() to read larger values or starting at a non-zero
    /// offset.
    pub fn r#read_descriptor(
        &self,
        mut id: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(fidl_fuchsia_bluetooth::Status, Vec<u8>), fidl::Error> {
        let _response = self.client.send_query::<
            RemoteServiceReadDescriptorRequest,
            RemoteServiceReadDescriptorResponse,
            RemoteServiceMarker,
        >(
            (id,),
            0x3d72215c1d23037a,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok((_response.status, _response.value))
    }

    /// Reads the complete value of a characteristic descriptor with the given `id`.
    /// This procedure should be used if the descriptor is known to have a value
    /// that can not be read in a single request.
    ///
    /// Returns up to `max_bytes` octets of the characteristic value starting at
    /// the given `offset`.
    ///
    /// This may return an error if:
    ///   a. `max_bytes` is 0;
    ///   b. The `offset` is invalid;
    ///   c. The server does not support the long read procedure.
    pub fn r#read_long_descriptor(
        &self,
        mut id: u64,
        mut offset: u16,
        mut max_bytes: u16,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(fidl_fuchsia_bluetooth::Status, Vec<u8>), fidl::Error> {
        let _response = self.client.send_query::<
            RemoteServiceReadLongDescriptorRequest,
            RemoteServiceReadLongDescriptorResponse,
            RemoteServiceMarker,
        >(
            (id, offset, max_bytes,),
            0x779efe322414240b,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok((_response.status, _response.value))
    }

    /// Writes `value` to the characteristic descriptor with `id`. This operation
    /// may return an error if:
    ///   a. The size of `value` exceeds the current MTU.
    ///   b. `id` refers to an internally reserved descriptor type (e.g. the Client
    ///      Characteristic Configuration descriptor).
    pub fn r#write_descriptor(
        &self,
        mut id: u64,
        mut value: &[u8],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<fidl_fuchsia_bluetooth::Status, fidl::Error> {
        let _response = self.client.send_query::<
            RemoteServiceWriteDescriptorRequest,
            RemoteServiceWriteDescriptorResponse,
            RemoteServiceMarker,
        >(
            (id, value,),
            0x24c813d96509895,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.status)
    }

    /// Writes `value` to the characteristic descriptor with `id`, beginning at
    /// `offset`. This procedure should be used if the value to be written is too
    /// long to fit in a single request or needs to be written at an offset. This
    /// may return an error if:
    ///   a. The `offset` is invalid;
    ///   b. The server does not support the long write procedure.
    ///   c. `id` refers to an internally reserved descriptor type (e.g. the Client
    ///      Characteristic Configuration descriptor).
    ///
    /// Long Writes require multiple messages to the remote service and take longer
    /// to execute than Short Writes. It is not recommended to send a short write
    /// while a long write is in process to the same id and data range. The order
    /// of the responses from this function signify the order in which the remote
    /// service received them, not necessarily the order in which it is called.
    pub fn r#write_long_descriptor(
        &self,
        mut id: u64,
        mut offset: u16,
        mut value: &[u8],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<fidl_fuchsia_bluetooth::Status, fidl::Error> {
        let _response = self.client.send_query::<
            RemoteServiceWriteLongDescriptorRequest,
            RemoteServiceWriteLongDescriptorResponse,
            RemoteServiceMarker,
        >(
            (id, offset, value,),
            0x653c9dbe0138b47,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.status)
    }

    /// Reads characteristics and descriptors with the given `uuid`. If no values are
    /// read, `results` will be empty. If reading a value results in a permission error,
    /// the handle and error will be included in `results`.
    ///
    /// NOTE: Values in `results` will be truncated to `MAX_READ_BY_TYPE_VALUE_LENGTH`
    /// bytes. `ReadCharacteristic`, `ReadLongCharacteristic()`, `ReadDescriptor`, or
    /// `ReadLongDescriptor()` should be used to read the complete values.
    ///
    /// This method is useful for reading values before discovery has completed, thereby
    /// reducing latency.
    pub fn r#read_by_type(
        &self,
        mut uuid: &fidl_fuchsia_bluetooth::Uuid,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RemoteServiceReadByTypeResult, fidl::Error> {
        let _response = self.client.send_query::<
            RemoteServiceReadByTypeRequest,
            fidl::encoding::ResultType<RemoteServiceReadByTypeResponse, Error>,
            RemoteServiceMarker,
        >(
            (uuid,),
            0x72e84b1d5eb5c245,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.results))
    }

    /// Subscribe or unsubscribe to notifications/indications from the characteristic with
    /// the given `id`. Notifications or indications will be enabled if `enable` is
    /// true or disabled if `enable` is false and they have been enabled for this
    /// client.
    ///
    /// Either notifications or indications will be enabled depending on
    /// characteristic properties. Indications will be preferred if they are
    /// supported.
    ///
    /// This operation fails if the characteristic does not have the "notify" or
    /// "indicate" property.
    ///
    /// A write request will be issued to configure the characteristic for notifications/indications
    /// if it contains a Client Characteristic Configuration descriptor. This method fails if an
    /// error occurs while writing to the descriptor.
    ///
    /// On success, the OnCharacteristicValueUpdated event will be sent whenever
    /// the peer sends a notification or indication. The local host will
    /// automically confirm indications.
    pub fn r#notify_characteristic(
        &self,
        mut id: u64,
        mut enable: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<fidl_fuchsia_bluetooth::Status, fidl::Error> {
        let _response = self.client.send_query::<
            RemoteServiceNotifyCharacteristicRequest,
            RemoteServiceNotifyCharacteristicResponse,
            RemoteServiceMarker,
        >(
            (id, enable,),
            0x615750fd68cbd159,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.status)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for RemoteServiceProxy {
    type Protocol = RemoteServiceMarker;

    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 RemoteServiceProxy {
    /// Create a new Proxy for fuchsia.bluetooth.gatt/RemoteService.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <RemoteServiceMarker 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) -> RemoteServiceEventStream {
        RemoteServiceEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Returns the characteristics and characteristic descriptors that belong to
    /// this service.
    pub fn r#discover_characteristics(
        &self,
    ) -> fidl::client::QueryResponseFut<
        (fidl_fuchsia_bluetooth::Status, Vec<Characteristic>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RemoteServiceProxyInterface::r#discover_characteristics(self)
    }

    /// Reads the value of the characteristic with `id` and returns it in the
    /// reply. If `status` indicates an error `value` will be empty.
    ///
    /// If the characteristic has a long value (i.e. larger than the current MTU)
    /// this method will return only the first (MTU - 1) bytes of the value. Use
    /// ReadLongCharacteristic() to read larger values or starting at a non-zero
    /// offset.
    pub fn r#read_characteristic(
        &self,
        mut id: u64,
    ) -> fidl::client::QueryResponseFut<
        (fidl_fuchsia_bluetooth::Status, Vec<u8>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RemoteServiceProxyInterface::r#read_characteristic(self, id)
    }

    /// Reads the complete value of a characteristic with the given `id`. This
    /// procedure should be used if the characteristic is known to have a value
    /// that can not be read in a single request.
    ///
    /// Returns up to `max_bytes` octets of the characteristic value starting at
    /// the given `offset`.
    ///
    /// This may return an error if:
    ///   a. `max_bytes` is 0;
    ///   b. The `offset` is invalid;
    ///   c. The characteristic does not have a long value;
    ///   d. The server does not support the long read procedure.
    pub fn r#read_long_characteristic(
        &self,
        mut id: u64,
        mut offset: u16,
        mut max_bytes: u16,
    ) -> fidl::client::QueryResponseFut<
        (fidl_fuchsia_bluetooth::Status, Vec<u8>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RemoteServiceProxyInterface::r#read_long_characteristic(self, id, offset, max_bytes)
    }

    /// Writes `value` to the characteristic with `id`. This operation may return
    /// an error if:
    ///   a. The size of `value` exceeds the current MTU.
    ///   b. The characteristic referred to by `id` does not have the 'write'
    ///      property.
    pub fn r#write_characteristic(
        &self,
        mut id: u64,
        mut value: &[u8],
    ) -> fidl::client::QueryResponseFut<
        fidl_fuchsia_bluetooth::Status,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RemoteServiceProxyInterface::r#write_characteristic(self, id, value)
    }

    /// Writes `value` to the characteristic with `id`, beginning at `offset` using
    /// the provided `write_options`.
    ///
    /// This procedure should be used if the value to be written is too long to
    /// fit in a single request or needs to be written at an offset. This may
    /// return an error if:
    ///   a. The `offset` is invalid;
    ///   b. The server does not support the long write procedure.
    ///
    /// Long Writes require multiple messages to the remote service and take longer
    /// to execute than Short Writes. It is not recommended to send a short write
    /// while a long write is in process to the same id and data range. The order
    /// of the responses from this function signify the order in which the remote
    /// service received them, not necessarily the order in which it is called.
    pub fn r#write_long_characteristic(
        &self,
        mut id: u64,
        mut offset: u16,
        mut value: &[u8],
        mut write_options: &WriteOptions,
    ) -> fidl::client::QueryResponseFut<
        fidl_fuchsia_bluetooth::Status,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RemoteServiceProxyInterface::r#write_long_characteristic(
            self,
            id,
            offset,
            value,
            write_options,
        )
    }

    /// Writes `value` to the characteristic with `id` without soliciting an
    /// acknowledgement from the peer. This method has no response and its delivery
    /// cannot be confirmed.
    pub fn r#write_characteristic_without_response(
        &self,
        mut id: u64,
        mut value: &[u8],
    ) -> Result<(), fidl::Error> {
        RemoteServiceProxyInterface::r#write_characteristic_without_response(self, id, value)
    }

    /// Reads the value of the characteristic descriptor with `id` and returns it
    /// in the reply. If `status` indicates an error, `value` can be ignored.
    ///
    /// If the descriptor has a long value (i.e. larger than the current MTU)
    /// this method will return only the first (MTU - 1) bytes of the value. Use
    /// ReadLongDescriptor() to read larger values or starting at a non-zero
    /// offset.
    pub fn r#read_descriptor(
        &self,
        mut id: u64,
    ) -> fidl::client::QueryResponseFut<
        (fidl_fuchsia_bluetooth::Status, Vec<u8>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RemoteServiceProxyInterface::r#read_descriptor(self, id)
    }

    /// Reads the complete value of a characteristic descriptor with the given `id`.
    /// This procedure should be used if the descriptor is known to have a value
    /// that can not be read in a single request.
    ///
    /// Returns up to `max_bytes` octets of the characteristic value starting at
    /// the given `offset`.
    ///
    /// This may return an error if:
    ///   a. `max_bytes` is 0;
    ///   b. The `offset` is invalid;
    ///   c. The server does not support the long read procedure.
    pub fn r#read_long_descriptor(
        &self,
        mut id: u64,
        mut offset: u16,
        mut max_bytes: u16,
    ) -> fidl::client::QueryResponseFut<
        (fidl_fuchsia_bluetooth::Status, Vec<u8>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RemoteServiceProxyInterface::r#read_long_descriptor(self, id, offset, max_bytes)
    }

    /// Writes `value` to the characteristic descriptor with `id`. This operation
    /// may return an error if:
    ///   a. The size of `value` exceeds the current MTU.
    ///   b. `id` refers to an internally reserved descriptor type (e.g. the Client
    ///      Characteristic Configuration descriptor).
    pub fn r#write_descriptor(
        &self,
        mut id: u64,
        mut value: &[u8],
    ) -> fidl::client::QueryResponseFut<
        fidl_fuchsia_bluetooth::Status,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RemoteServiceProxyInterface::r#write_descriptor(self, id, value)
    }

    /// Writes `value` to the characteristic descriptor with `id`, beginning at
    /// `offset`. This procedure should be used if the value to be written is too
    /// long to fit in a single request or needs to be written at an offset. This
    /// may return an error if:
    ///   a. The `offset` is invalid;
    ///   b. The server does not support the long write procedure.
    ///   c. `id` refers to an internally reserved descriptor type (e.g. the Client
    ///      Characteristic Configuration descriptor).
    ///
    /// Long Writes require multiple messages to the remote service and take longer
    /// to execute than Short Writes. It is not recommended to send a short write
    /// while a long write is in process to the same id and data range. The order
    /// of the responses from this function signify the order in which the remote
    /// service received them, not necessarily the order in which it is called.
    pub fn r#write_long_descriptor(
        &self,
        mut id: u64,
        mut offset: u16,
        mut value: &[u8],
    ) -> fidl::client::QueryResponseFut<
        fidl_fuchsia_bluetooth::Status,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RemoteServiceProxyInterface::r#write_long_descriptor(self, id, offset, value)
    }

    /// Reads characteristics and descriptors with the given `uuid`. If no values are
    /// read, `results` will be empty. If reading a value results in a permission error,
    /// the handle and error will be included in `results`.
    ///
    /// NOTE: Values in `results` will be truncated to `MAX_READ_BY_TYPE_VALUE_LENGTH`
    /// bytes. `ReadCharacteristic`, `ReadLongCharacteristic()`, `ReadDescriptor`, or
    /// `ReadLongDescriptor()` should be used to read the complete values.
    ///
    /// This method is useful for reading values before discovery has completed, thereby
    /// reducing latency.
    pub fn r#read_by_type(
        &self,
        mut uuid: &fidl_fuchsia_bluetooth::Uuid,
    ) -> fidl::client::QueryResponseFut<
        RemoteServiceReadByTypeResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RemoteServiceProxyInterface::r#read_by_type(self, uuid)
    }

    /// Subscribe or unsubscribe to notifications/indications from the characteristic with
    /// the given `id`. Notifications or indications will be enabled if `enable` is
    /// true or disabled if `enable` is false and they have been enabled for this
    /// client.
    ///
    /// Either notifications or indications will be enabled depending on
    /// characteristic properties. Indications will be preferred if they are
    /// supported.
    ///
    /// This operation fails if the characteristic does not have the "notify" or
    /// "indicate" property.
    ///
    /// A write request will be issued to configure the characteristic for notifications/indications
    /// if it contains a Client Characteristic Configuration descriptor. This method fails if an
    /// error occurs while writing to the descriptor.
    ///
    /// On success, the OnCharacteristicValueUpdated event will be sent whenever
    /// the peer sends a notification or indication. The local host will
    /// automically confirm indications.
    pub fn r#notify_characteristic(
        &self,
        mut id: u64,
        mut enable: bool,
    ) -> fidl::client::QueryResponseFut<
        fidl_fuchsia_bluetooth::Status,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RemoteServiceProxyInterface::r#notify_characteristic(self, id, enable)
    }
}

impl RemoteServiceProxyInterface for RemoteServiceProxy {
    type DiscoverCharacteristicsResponseFut = fidl::client::QueryResponseFut<
        (fidl_fuchsia_bluetooth::Status, Vec<Characteristic>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#discover_characteristics(&self) -> Self::DiscoverCharacteristicsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(fidl_fuchsia_bluetooth::Status, Vec<Characteristic>), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                RemoteServiceDiscoverCharacteristicsResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4c13b72543a8aa16,
            >(_buf?)?;
            Ok((_response.status, _response.characteristics))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            (fidl_fuchsia_bluetooth::Status, Vec<Characteristic>),
        >(
            (),
            0x4c13b72543a8aa16,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ReadCharacteristicResponseFut = fidl::client::QueryResponseFut<
        (fidl_fuchsia_bluetooth::Status, Vec<u8>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#read_characteristic(&self, mut id: u64) -> Self::ReadCharacteristicResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(fidl_fuchsia_bluetooth::Status, Vec<u8>), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                RemoteServiceReadCharacteristicResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x200a5253bc0771c8,
            >(_buf?)?;
            Ok((_response.status, _response.value))
        }
        self.client.send_query_and_decode::<
            RemoteServiceReadCharacteristicRequest,
            (fidl_fuchsia_bluetooth::Status, Vec<u8>),
        >(
            (id,),
            0x200a5253bc0771c8,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ReadLongCharacteristicResponseFut = fidl::client::QueryResponseFut<
        (fidl_fuchsia_bluetooth::Status, Vec<u8>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#read_long_characteristic(
        &self,
        mut id: u64,
        mut offset: u16,
        mut max_bytes: u16,
    ) -> Self::ReadLongCharacteristicResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(fidl_fuchsia_bluetooth::Status, Vec<u8>), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                RemoteServiceReadLongCharacteristicResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2df2f20845555766,
            >(_buf?)?;
            Ok((_response.status, _response.value))
        }
        self.client.send_query_and_decode::<
            RemoteServiceReadLongCharacteristicRequest,
            (fidl_fuchsia_bluetooth::Status, Vec<u8>),
        >(
            (id, offset, max_bytes,),
            0x2df2f20845555766,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type WriteCharacteristicResponseFut = fidl::client::QueryResponseFut<
        fidl_fuchsia_bluetooth::Status,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#write_characteristic(
        &self,
        mut id: u64,
        mut value: &[u8],
    ) -> Self::WriteCharacteristicResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<fidl_fuchsia_bluetooth::Status, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                RemoteServiceWriteCharacteristicResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5c1f529653cdad04,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<
            RemoteServiceWriteCharacteristicRequest,
            fidl_fuchsia_bluetooth::Status,
        >(
            (id, value,),
            0x5c1f529653cdad04,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type WriteLongCharacteristicResponseFut = fidl::client::QueryResponseFut<
        fidl_fuchsia_bluetooth::Status,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#write_long_characteristic(
        &self,
        mut id: u64,
        mut offset: u16,
        mut value: &[u8],
        mut write_options: &WriteOptions,
    ) -> Self::WriteLongCharacteristicResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<fidl_fuchsia_bluetooth::Status, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                RemoteServiceWriteLongCharacteristicResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2d358800658043e1,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<
            RemoteServiceWriteLongCharacteristicRequest,
            fidl_fuchsia_bluetooth::Status,
        >(
            (id, offset, value, write_options,),
            0x2d358800658043e1,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#write_characteristic_without_response(
        &self,
        mut id: u64,
        mut value: &[u8],
    ) -> Result<(), fidl::Error> {
        self.client.send::<RemoteServiceWriteCharacteristicWithoutResponseRequest>(
            (id, value),
            0x6eee4a248275f56e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type ReadDescriptorResponseFut = fidl::client::QueryResponseFut<
        (fidl_fuchsia_bluetooth::Status, Vec<u8>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#read_descriptor(&self, mut id: u64) -> Self::ReadDescriptorResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(fidl_fuchsia_bluetooth::Status, Vec<u8>), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                RemoteServiceReadDescriptorResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3d72215c1d23037a,
            >(_buf?)?;
            Ok((_response.status, _response.value))
        }
        self.client.send_query_and_decode::<
            RemoteServiceReadDescriptorRequest,
            (fidl_fuchsia_bluetooth::Status, Vec<u8>),
        >(
            (id,),
            0x3d72215c1d23037a,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ReadLongDescriptorResponseFut = fidl::client::QueryResponseFut<
        (fidl_fuchsia_bluetooth::Status, Vec<u8>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#read_long_descriptor(
        &self,
        mut id: u64,
        mut offset: u16,
        mut max_bytes: u16,
    ) -> Self::ReadLongDescriptorResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(fidl_fuchsia_bluetooth::Status, Vec<u8>), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                RemoteServiceReadLongDescriptorResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x779efe322414240b,
            >(_buf?)?;
            Ok((_response.status, _response.value))
        }
        self.client.send_query_and_decode::<
            RemoteServiceReadLongDescriptorRequest,
            (fidl_fuchsia_bluetooth::Status, Vec<u8>),
        >(
            (id, offset, max_bytes,),
            0x779efe322414240b,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type WriteDescriptorResponseFut = fidl::client::QueryResponseFut<
        fidl_fuchsia_bluetooth::Status,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#write_descriptor(
        &self,
        mut id: u64,
        mut value: &[u8],
    ) -> Self::WriteDescriptorResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<fidl_fuchsia_bluetooth::Status, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                RemoteServiceWriteDescriptorResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x24c813d96509895,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<
            RemoteServiceWriteDescriptorRequest,
            fidl_fuchsia_bluetooth::Status,
        >(
            (id, value,),
            0x24c813d96509895,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type WriteLongDescriptorResponseFut = fidl::client::QueryResponseFut<
        fidl_fuchsia_bluetooth::Status,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#write_long_descriptor(
        &self,
        mut id: u64,
        mut offset: u16,
        mut value: &[u8],
    ) -> Self::WriteLongDescriptorResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<fidl_fuchsia_bluetooth::Status, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                RemoteServiceWriteLongDescriptorResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x653c9dbe0138b47,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<
            RemoteServiceWriteLongDescriptorRequest,
            fidl_fuchsia_bluetooth::Status,
        >(
            (id, offset, value,),
            0x653c9dbe0138b47,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ReadByTypeResponseFut = fidl::client::QueryResponseFut<
        RemoteServiceReadByTypeResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#read_by_type(
        &self,
        mut uuid: &fidl_fuchsia_bluetooth::Uuid,
    ) -> Self::ReadByTypeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RemoteServiceReadByTypeResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<RemoteServiceReadByTypeResponse, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x72e84b1d5eb5c245,
            >(_buf?)?;
            Ok(_response.map(|x| x.results))
        }
        self.client
            .send_query_and_decode::<RemoteServiceReadByTypeRequest, RemoteServiceReadByTypeResult>(
                (uuid,),
                0x72e84b1d5eb5c245,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type NotifyCharacteristicResponseFut = fidl::client::QueryResponseFut<
        fidl_fuchsia_bluetooth::Status,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#notify_characteristic(
        &self,
        mut id: u64,
        mut enable: bool,
    ) -> Self::NotifyCharacteristicResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<fidl_fuchsia_bluetooth::Status, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                RemoteServiceNotifyCharacteristicResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x615750fd68cbd159,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<
            RemoteServiceNotifyCharacteristicRequest,
            fidl_fuchsia_bluetooth::Status,
        >(
            (id, enable,),
            0x615750fd68cbd159,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

#[derive(Debug)]
pub enum RemoteServiceEvent {
    OnCharacteristicValueUpdated { id: u64, value: Vec<u8> },
}

impl RemoteServiceEvent {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_characteristic_value_updated(self) -> Option<(u64, Vec<u8>)> {
        if let RemoteServiceEvent::OnCharacteristicValueUpdated { id, value } = self {
            Some((id, value))
        } else {
            None
        }
    }

    /// Decodes a message buffer as a [`RemoteServiceEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<RemoteServiceEvent, 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 {
            0x304debe9d0408fac => {
                let mut out = fidl::new_empty!(
                    RemoteServiceOnCharacteristicValueUpdatedRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RemoteServiceOnCharacteristicValueUpdatedRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((RemoteServiceEvent::OnCharacteristicValueUpdated {
                    id: out.id,
                    value: out.value,
                }))
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <RemoteServiceMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fidl::endpoints::RequestStream for RemoteServiceRequestStream {
    type Protocol = RemoteServiceMarker;
    type ControlHandle = RemoteServiceControlHandle;

    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 {
        RemoteServiceControlHandle { 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 RemoteServiceRequestStream {
    type Item = Result<RemoteServiceRequest, 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 RemoteServiceRequestStream 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 {
                    0x4c13b72543a8aa16 => {
                        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 =
                            RemoteServiceControlHandle { inner: this.inner.clone() };
                        Ok(RemoteServiceRequest::DiscoverCharacteristics {
                            responder: RemoteServiceDiscoverCharacteristicsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x200a5253bc0771c8 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RemoteServiceReadCharacteristicRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RemoteServiceReadCharacteristicRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            RemoteServiceControlHandle { inner: this.inner.clone() };
                        Ok(RemoteServiceRequest::ReadCharacteristic {
                            id: req.id,

                            responder: RemoteServiceReadCharacteristicResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2df2f20845555766 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RemoteServiceReadLongCharacteristicRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RemoteServiceReadLongCharacteristicRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            RemoteServiceControlHandle { inner: this.inner.clone() };
                        Ok(RemoteServiceRequest::ReadLongCharacteristic {
                            id: req.id,
                            offset: req.offset,
                            max_bytes: req.max_bytes,

                            responder: RemoteServiceReadLongCharacteristicResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5c1f529653cdad04 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RemoteServiceWriteCharacteristicRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RemoteServiceWriteCharacteristicRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            RemoteServiceControlHandle { inner: this.inner.clone() };
                        Ok(RemoteServiceRequest::WriteCharacteristic {
                            id: req.id,
                            value: req.value,

                            responder: RemoteServiceWriteCharacteristicResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2d358800658043e1 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RemoteServiceWriteLongCharacteristicRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RemoteServiceWriteLongCharacteristicRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            RemoteServiceControlHandle { inner: this.inner.clone() };
                        Ok(RemoteServiceRequest::WriteLongCharacteristic {
                            id: req.id,
                            offset: req.offset,
                            value: req.value,
                            write_options: req.write_options,

                            responder: RemoteServiceWriteLongCharacteristicResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6eee4a248275f56e => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            RemoteServiceWriteCharacteristicWithoutResponseRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RemoteServiceWriteCharacteristicWithoutResponseRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            RemoteServiceControlHandle { inner: this.inner.clone() };
                        Ok(RemoteServiceRequest::WriteCharacteristicWithoutResponse {
                            id: req.id,
                            value: req.value,

                            control_handle,
                        })
                    }
                    0x3d72215c1d23037a => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RemoteServiceReadDescriptorRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RemoteServiceReadDescriptorRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            RemoteServiceControlHandle { inner: this.inner.clone() };
                        Ok(RemoteServiceRequest::ReadDescriptor {
                            id: req.id,

                            responder: RemoteServiceReadDescriptorResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x779efe322414240b => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RemoteServiceReadLongDescriptorRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RemoteServiceReadLongDescriptorRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            RemoteServiceControlHandle { inner: this.inner.clone() };
                        Ok(RemoteServiceRequest::ReadLongDescriptor {
                            id: req.id,
                            offset: req.offset,
                            max_bytes: req.max_bytes,

                            responder: RemoteServiceReadLongDescriptorResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x24c813d96509895 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RemoteServiceWriteDescriptorRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RemoteServiceWriteDescriptorRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            RemoteServiceControlHandle { inner: this.inner.clone() };
                        Ok(RemoteServiceRequest::WriteDescriptor {
                            id: req.id,
                            value: req.value,

                            responder: RemoteServiceWriteDescriptorResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x653c9dbe0138b47 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RemoteServiceWriteLongDescriptorRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RemoteServiceWriteLongDescriptorRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            RemoteServiceControlHandle { inner: this.inner.clone() };
                        Ok(RemoteServiceRequest::WriteLongDescriptor {
                            id: req.id,
                            offset: req.offset,
                            value: req.value,

                            responder: RemoteServiceWriteLongDescriptorResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x72e84b1d5eb5c245 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RemoteServiceReadByTypeRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RemoteServiceReadByTypeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            RemoteServiceControlHandle { inner: this.inner.clone() };
                        Ok(RemoteServiceRequest::ReadByType {
                            uuid: req.uuid,

                            responder: RemoteServiceReadByTypeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x615750fd68cbd159 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RemoteServiceNotifyCharacteristicRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RemoteServiceNotifyCharacteristicRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            RemoteServiceControlHandle { inner: this.inner.clone() };
                        Ok(RemoteServiceRequest::NotifyCharacteristic {
                            id: req.id,
                            enable: req.enable,

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

#[derive(Debug)]
pub enum RemoteServiceRequest {
    /// Returns the characteristics and characteristic descriptors that belong to
    /// this service.
    DiscoverCharacteristics { responder: RemoteServiceDiscoverCharacteristicsResponder },
    /// Reads the value of the characteristic with `id` and returns it in the
    /// reply. If `status` indicates an error `value` will be empty.
    ///
    /// If the characteristic has a long value (i.e. larger than the current MTU)
    /// this method will return only the first (MTU - 1) bytes of the value. Use
    /// ReadLongCharacteristic() to read larger values or starting at a non-zero
    /// offset.
    ReadCharacteristic { id: u64, responder: RemoteServiceReadCharacteristicResponder },
    /// Reads the complete value of a characteristic with the given `id`. This
    /// procedure should be used if the characteristic is known to have a value
    /// that can not be read in a single request.
    ///
    /// Returns up to `max_bytes` octets of the characteristic value starting at
    /// the given `offset`.
    ///
    /// This may return an error if:
    ///   a. `max_bytes` is 0;
    ///   b. The `offset` is invalid;
    ///   c. The characteristic does not have a long value;
    ///   d. The server does not support the long read procedure.
    ReadLongCharacteristic {
        id: u64,
        offset: u16,
        max_bytes: u16,
        responder: RemoteServiceReadLongCharacteristicResponder,
    },
    /// Writes `value` to the characteristic with `id`. This operation may return
    /// an error if:
    ///   a. The size of `value` exceeds the current MTU.
    ///   b. The characteristic referred to by `id` does not have the 'write'
    ///      property.
    WriteCharacteristic {
        id: u64,
        value: Vec<u8>,
        responder: RemoteServiceWriteCharacteristicResponder,
    },
    /// Writes `value` to the characteristic with `id`, beginning at `offset` using
    /// the provided `write_options`.
    ///
    /// This procedure should be used if the value to be written is too long to
    /// fit in a single request or needs to be written at an offset. This may
    /// return an error if:
    ///   a. The `offset` is invalid;
    ///   b. The server does not support the long write procedure.
    ///
    /// Long Writes require multiple messages to the remote service and take longer
    /// to execute than Short Writes. It is not recommended to send a short write
    /// while a long write is in process to the same id and data range. The order
    /// of the responses from this function signify the order in which the remote
    /// service received them, not necessarily the order in which it is called.
    WriteLongCharacteristic {
        id: u64,
        offset: u16,
        value: Vec<u8>,
        write_options: WriteOptions,
        responder: RemoteServiceWriteLongCharacteristicResponder,
    },
    /// Writes `value` to the characteristic with `id` without soliciting an
    /// acknowledgement from the peer. This method has no response and its delivery
    /// cannot be confirmed.
    WriteCharacteristicWithoutResponse {
        id: u64,
        value: Vec<u8>,
        control_handle: RemoteServiceControlHandle,
    },
    /// Reads the value of the characteristic descriptor with `id` and returns it
    /// in the reply. If `status` indicates an error, `value` can be ignored.
    ///
    /// If the descriptor has a long value (i.e. larger than the current MTU)
    /// this method will return only the first (MTU - 1) bytes of the value. Use
    /// ReadLongDescriptor() to read larger values or starting at a non-zero
    /// offset.
    ReadDescriptor { id: u64, responder: RemoteServiceReadDescriptorResponder },
    /// Reads the complete value of a characteristic descriptor with the given `id`.
    /// This procedure should be used if the descriptor is known to have a value
    /// that can not be read in a single request.
    ///
    /// Returns up to `max_bytes` octets of the characteristic value starting at
    /// the given `offset`.
    ///
    /// This may return an error if:
    ///   a. `max_bytes` is 0;
    ///   b. The `offset` is invalid;
    ///   c. The server does not support the long read procedure.
    ReadLongDescriptor {
        id: u64,
        offset: u16,
        max_bytes: u16,
        responder: RemoteServiceReadLongDescriptorResponder,
    },
    /// Writes `value` to the characteristic descriptor with `id`. This operation
    /// may return an error if:
    ///   a. The size of `value` exceeds the current MTU.
    ///   b. `id` refers to an internally reserved descriptor type (e.g. the Client
    ///      Characteristic Configuration descriptor).
    WriteDescriptor { id: u64, value: Vec<u8>, responder: RemoteServiceWriteDescriptorResponder },
    /// Writes `value` to the characteristic descriptor with `id`, beginning at
    /// `offset`. This procedure should be used if the value to be written is too
    /// long to fit in a single request or needs to be written at an offset. This
    /// may return an error if:
    ///   a. The `offset` is invalid;
    ///   b. The server does not support the long write procedure.
    ///   c. `id` refers to an internally reserved descriptor type (e.g. the Client
    ///      Characteristic Configuration descriptor).
    ///
    /// Long Writes require multiple messages to the remote service and take longer
    /// to execute than Short Writes. It is not recommended to send a short write
    /// while a long write is in process to the same id and data range. The order
    /// of the responses from this function signify the order in which the remote
    /// service received them, not necessarily the order in which it is called.
    WriteLongDescriptor {
        id: u64,
        offset: u16,
        value: Vec<u8>,
        responder: RemoteServiceWriteLongDescriptorResponder,
    },
    /// Reads characteristics and descriptors with the given `uuid`. If no values are
    /// read, `results` will be empty. If reading a value results in a permission error,
    /// the handle and error will be included in `results`.
    ///
    /// NOTE: Values in `results` will be truncated to `MAX_READ_BY_TYPE_VALUE_LENGTH`
    /// bytes. `ReadCharacteristic`, `ReadLongCharacteristic()`, `ReadDescriptor`, or
    /// `ReadLongDescriptor()` should be used to read the complete values.
    ///
    /// This method is useful for reading values before discovery has completed, thereby
    /// reducing latency.
    ReadByType { uuid: fidl_fuchsia_bluetooth::Uuid, responder: RemoteServiceReadByTypeResponder },
    /// Subscribe or unsubscribe to notifications/indications from the characteristic with
    /// the given `id`. Notifications or indications will be enabled if `enable` is
    /// true or disabled if `enable` is false and they have been enabled for this
    /// client.
    ///
    /// Either notifications or indications will be enabled depending on
    /// characteristic properties. Indications will be preferred if they are
    /// supported.
    ///
    /// This operation fails if the characteristic does not have the "notify" or
    /// "indicate" property.
    ///
    /// A write request will be issued to configure the characteristic for notifications/indications
    /// if it contains a Client Characteristic Configuration descriptor. This method fails if an
    /// error occurs while writing to the descriptor.
    ///
    /// On success, the OnCharacteristicValueUpdated event will be sent whenever
    /// the peer sends a notification or indication. The local host will
    /// automically confirm indications.
    NotifyCharacteristic {
        id: u64,
        enable: bool,
        responder: RemoteServiceNotifyCharacteristicResponder,
    },
}

impl RemoteServiceRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_discover_characteristics(
        self,
    ) -> Option<(RemoteServiceDiscoverCharacteristicsResponder)> {
        if let RemoteServiceRequest::DiscoverCharacteristics { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_read_characteristic(
        self,
    ) -> Option<(u64, RemoteServiceReadCharacteristicResponder)> {
        if let RemoteServiceRequest::ReadCharacteristic { id, responder } = self {
            Some((id, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_read_long_characteristic(
        self,
    ) -> Option<(u64, u16, u16, RemoteServiceReadLongCharacteristicResponder)> {
        if let RemoteServiceRequest::ReadLongCharacteristic { id, offset, max_bytes, responder } =
            self
        {
            Some((id, offset, max_bytes, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_write_characteristic(
        self,
    ) -> Option<(u64, Vec<u8>, RemoteServiceWriteCharacteristicResponder)> {
        if let RemoteServiceRequest::WriteCharacteristic { id, value, responder } = self {
            Some((id, value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_write_long_characteristic(
        self,
    ) -> Option<(u64, u16, Vec<u8>, WriteOptions, RemoteServiceWriteLongCharacteristicResponder)>
    {
        if let RemoteServiceRequest::WriteLongCharacteristic {
            id,
            offset,
            value,
            write_options,
            responder,
        } = self
        {
            Some((id, offset, value, write_options, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_write_characteristic_without_response(
        self,
    ) -> Option<(u64, Vec<u8>, RemoteServiceControlHandle)> {
        if let RemoteServiceRequest::WriteCharacteristicWithoutResponse {
            id,
            value,
            control_handle,
        } = self
        {
            Some((id, value, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_read_descriptor(self) -> Option<(u64, RemoteServiceReadDescriptorResponder)> {
        if let RemoteServiceRequest::ReadDescriptor { id, responder } = self {
            Some((id, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_read_long_descriptor(
        self,
    ) -> Option<(u64, u16, u16, RemoteServiceReadLongDescriptorResponder)> {
        if let RemoteServiceRequest::ReadLongDescriptor { id, offset, max_bytes, responder } = self
        {
            Some((id, offset, max_bytes, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_write_descriptor(
        self,
    ) -> Option<(u64, Vec<u8>, RemoteServiceWriteDescriptorResponder)> {
        if let RemoteServiceRequest::WriteDescriptor { id, value, responder } = self {
            Some((id, value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_write_long_descriptor(
        self,
    ) -> Option<(u64, u16, Vec<u8>, RemoteServiceWriteLongDescriptorResponder)> {
        if let RemoteServiceRequest::WriteLongDescriptor { id, offset, value, responder } = self {
            Some((id, offset, value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_read_by_type(
        self,
    ) -> Option<(fidl_fuchsia_bluetooth::Uuid, RemoteServiceReadByTypeResponder)> {
        if let RemoteServiceRequest::ReadByType { uuid, responder } = self {
            Some((uuid, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_notify_characteristic(
        self,
    ) -> Option<(u64, bool, RemoteServiceNotifyCharacteristicResponder)> {
        if let RemoteServiceRequest::NotifyCharacteristic { id, enable, responder } = self {
            Some((id, enable, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            RemoteServiceRequest::DiscoverCharacteristics { .. } => "discover_characteristics",
            RemoteServiceRequest::ReadCharacteristic { .. } => "read_characteristic",
            RemoteServiceRequest::ReadLongCharacteristic { .. } => "read_long_characteristic",
            RemoteServiceRequest::WriteCharacteristic { .. } => "write_characteristic",
            RemoteServiceRequest::WriteLongCharacteristic { .. } => "write_long_characteristic",
            RemoteServiceRequest::WriteCharacteristicWithoutResponse { .. } => {
                "write_characteristic_without_response"
            }
            RemoteServiceRequest::ReadDescriptor { .. } => "read_descriptor",
            RemoteServiceRequest::ReadLongDescriptor { .. } => "read_long_descriptor",
            RemoteServiceRequest::WriteDescriptor { .. } => "write_descriptor",
            RemoteServiceRequest::WriteLongDescriptor { .. } => "write_long_descriptor",
            RemoteServiceRequest::ReadByType { .. } => "read_by_type",
            RemoteServiceRequest::NotifyCharacteristic { .. } => "notify_characteristic",
        }
    }
}

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

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

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

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&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 RemoteServiceControlHandle {
    pub fn send_on_characteristic_value_updated(
        &self,
        mut id: u64,
        mut value: &[u8],
    ) -> Result<(), fidl::Error> {
        self.inner.send::<RemoteServiceOnCharacteristicValueUpdatedRequest>(
            (id, value),
            0,
            0x304debe9d0408fac,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

    fn send_raw(
        &self,
        mut status: &fidl_fuchsia_bluetooth::Status,
        mut characteristics: &[Characteristic],
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<RemoteServiceDiscoverCharacteristicsResponse>(
            (status, characteristics),
            self.tx_id,
            0x4c13b72543a8aa16,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

    fn send_raw(
        &self,
        mut status: &fidl_fuchsia_bluetooth::Status,
        mut value: &[u8],
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<RemoteServiceReadCharacteristicResponse>(
            (status, value),
            self.tx_id,
            0x200a5253bc0771c8,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

    fn send_raw(
        &self,
        mut status: &fidl_fuchsia_bluetooth::Status,
        mut value: &[u8],
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<RemoteServiceReadLongCharacteristicResponse>(
            (status, value),
            self.tx_id,
            0x2df2f20845555766,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

    fn send_raw(&self, mut status: &fidl_fuchsia_bluetooth::Status) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<RemoteServiceWriteCharacteristicResponse>(
            (status,),
            self.tx_id,
            0x5c1f529653cdad04,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

    fn send_raw(&self, mut status: &fidl_fuchsia_bluetooth::Status) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<RemoteServiceWriteLongCharacteristicResponse>(
            (status,),
            self.tx_id,
            0x2d358800658043e1,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

    fn send_raw(
        &self,
        mut status: &fidl_fuchsia_bluetooth::Status,
        mut value: &[u8],
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<RemoteServiceReadDescriptorResponse>(
            (status, value),
            self.tx_id,
            0x3d72215c1d23037a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

    fn send_raw(
        &self,
        mut status: &fidl_fuchsia_bluetooth::Status,
        mut value: &[u8],
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<RemoteServiceReadLongDescriptorResponse>(
            (status, value),
            self.tx_id,
            0x779efe322414240b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

    fn send_raw(&self, mut status: &fidl_fuchsia_bluetooth::Status) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<RemoteServiceWriteDescriptorResponse>(
            (status,),
            self.tx_id,
            0x24c813d96509895,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

    fn send_raw(&self, mut status: &fidl_fuchsia_bluetooth::Status) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<RemoteServiceWriteLongDescriptorResponse>(
            (status,),
            self.tx_id,
            0x653c9dbe0138b47,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut result: Result<&[ReadByTypeResult], Error>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<RemoteServiceReadByTypeResponse, Error>>(
                result.map(|results| (results,)),
                self.tx_id,
                0x72e84b1d5eb5c245,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

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

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

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

    fn send_raw(&self, mut status: &fidl_fuchsia_bluetooth::Status) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<RemoteServiceNotifyCharacteristicResponse>(
            (status,),
            self.tx_id,
            0x615750fd68cbd159,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for Server_Marker {
    type Proxy = Server_Proxy;
    type RequestStream = Server_RequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = Server_SynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.bluetooth.gatt.Server";
}
impl fidl::endpoints::DiscoverableProtocolMarker for Server_Marker {}

pub trait Server_ProxyInterface: Send + Sync {
    type PublishServiceResponseFut: std::future::Future<Output = Result<fidl_fuchsia_bluetooth::Status, fidl::Error>>
        + Send;
    fn r#publish_service(
        &self,
        info: &ServiceInfo,
        delegate: fidl::endpoints::ClientEnd<LocalServiceDelegateMarker>,
        service: fidl::endpoints::ServerEnd<LocalServiceMarker>,
    ) -> Self::PublishServiceResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct Server_SynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for Server_SynchronousProxy {
    type Proxy = Server_Proxy;
    type Protocol = Server_Marker;

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

    /// Publishes the given service so that it is available to all remote peers.
    /// A LocalServiceDelegate must be provided over which to receive service requests.
    ///
    /// The caller must assign distinct identifiers to the characteristics and
    /// descriptors listed in `info`. These identifiers will be used in requests
    /// sent to `delegate`.
    ///
    /// `service` can be used to interact with the pubished service. If this
    /// service cannot be published then the handle for `service` will be closed.
    ///
    /// Returns the success or failure status of the call and a unique identifier
    /// that can be used to unregister the service.
    pub fn r#publish_service(
        &self,
        mut info: &ServiceInfo,
        mut delegate: fidl::endpoints::ClientEnd<LocalServiceDelegateMarker>,
        mut service: fidl::endpoints::ServerEnd<LocalServiceMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<fidl_fuchsia_bluetooth::Status, fidl::Error> {
        let _response = self
            .client
            .send_query::<ServerPublishServiceRequest, ServerPublishServiceResponse, Server_Marker>(
                (info, delegate, service),
                0x3b8b6f0988adb8c2,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.status)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for Server_Proxy {
    type Protocol = Server_Marker;

    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 Server_Proxy {
    /// Create a new Proxy for fuchsia.bluetooth.gatt/Server.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <Server_Marker 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) -> Server_EventStream {
        Server_EventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Publishes the given service so that it is available to all remote peers.
    /// A LocalServiceDelegate must be provided over which to receive service requests.
    ///
    /// The caller must assign distinct identifiers to the characteristics and
    /// descriptors listed in `info`. These identifiers will be used in requests
    /// sent to `delegate`.
    ///
    /// `service` can be used to interact with the pubished service. If this
    /// service cannot be published then the handle for `service` will be closed.
    ///
    /// Returns the success or failure status of the call and a unique identifier
    /// that can be used to unregister the service.
    pub fn r#publish_service(
        &self,
        mut info: &ServiceInfo,
        mut delegate: fidl::endpoints::ClientEnd<LocalServiceDelegateMarker>,
        mut service: fidl::endpoints::ServerEnd<LocalServiceMarker>,
    ) -> fidl::client::QueryResponseFut<
        fidl_fuchsia_bluetooth::Status,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        Server_ProxyInterface::r#publish_service(self, info, delegate, service)
    }
}

impl Server_ProxyInterface for Server_Proxy {
    type PublishServiceResponseFut = fidl::client::QueryResponseFut<
        fidl_fuchsia_bluetooth::Status,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#publish_service(
        &self,
        mut info: &ServiceInfo,
        mut delegate: fidl::endpoints::ClientEnd<LocalServiceDelegateMarker>,
        mut service: fidl::endpoints::ServerEnd<LocalServiceMarker>,
    ) -> Self::PublishServiceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<fidl_fuchsia_bluetooth::Status, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ServerPublishServiceResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3b8b6f0988adb8c2,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client
            .send_query_and_decode::<ServerPublishServiceRequest, fidl_fuchsia_bluetooth::Status>(
                (info, delegate, service),
                0x3b8b6f0988adb8c2,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for Server_RequestStream {
    type Protocol = Server_Marker;
    type ControlHandle = Server_ControlHandle;

    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 {
        Server_ControlHandle { 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 Server_RequestStream {
    type Item = Result<Server_Request, 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 Server_RequestStream 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 {
                    0x3b8b6f0988adb8c2 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ServerPublishServiceRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ServerPublishServiceRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = Server_ControlHandle { inner: this.inner.clone() };
                        Ok(Server_Request::PublishService {
                            info: req.info,
                            delegate: req.delegate,
                            service: req.service,

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

#[derive(Debug)]
pub enum Server_Request {
    /// Publishes the given service so that it is available to all remote peers.
    /// A LocalServiceDelegate must be provided over which to receive service requests.
    ///
    /// The caller must assign distinct identifiers to the characteristics and
    /// descriptors listed in `info`. These identifiers will be used in requests
    /// sent to `delegate`.
    ///
    /// `service` can be used to interact with the pubished service. If this
    /// service cannot be published then the handle for `service` will be closed.
    ///
    /// Returns the success or failure status of the call and a unique identifier
    /// that can be used to unregister the service.
    PublishService {
        info: ServiceInfo,
        delegate: fidl::endpoints::ClientEnd<LocalServiceDelegateMarker>,
        service: fidl::endpoints::ServerEnd<LocalServiceMarker>,
        responder: Server_PublishServiceResponder,
    },
}

impl Server_Request {
    #[allow(irrefutable_let_patterns)]
    pub fn into_publish_service(
        self,
    ) -> Option<(
        ServiceInfo,
        fidl::endpoints::ClientEnd<LocalServiceDelegateMarker>,
        fidl::endpoints::ServerEnd<LocalServiceMarker>,
        Server_PublishServiceResponder,
    )> {
        if let Server_Request::PublishService { info, delegate, service, responder } = self {
            Some((info, delegate, service, responder))
        } else {
            None
        }
    }

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

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut status: &fidl_fuchsia_bluetooth::Status) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<ServerPublishServiceResponse>(
            (status,),
            self.tx_id,
            0x3b8b6f0988adb8c2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

mod internal {
    use super::*;

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ClientConnectToServiceRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                id: fidl::new_empty!(u64, fidl::encoding::DefaultFuchsiaResourceDialect),
                service: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<RemoteServiceMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            ServerPublishServiceRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ServerPublishServiceRequest
    {
        #[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::<ServerPublishServiceRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ServerPublishServiceRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <ServiceInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.info),
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<LocalServiceDelegateMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.delegate),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<LocalServiceMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.service),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<ServiceInfo, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<LocalServiceDelegateMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T2: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<LocalServiceMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            ServerPublishServiceRequest,
            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::<ServerPublishServiceRequest>(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 + 64, depth)?;
            self.2.encode(encoder, offset + 68, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ServerPublishServiceRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                info: fidl::new_empty!(ServiceInfo, fidl::encoding::DefaultFuchsiaResourceDialect),
                delegate: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<LocalServiceDelegateMarker>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                service: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<LocalServiceMarker>>,
                    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!(
                ServiceInfo,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.info,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<LocalServiceDelegateMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.delegate,
                decoder,
                offset + 64,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<LocalServiceMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.service,
                decoder,
                offset + 68,
                _depth
            )?;
            Ok(())
        }
    }
}