fidl_fuchsia_bluetooth_gatt2/

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

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

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

#[derive(Debug, PartialEq)]
pub struct LocalServiceOnIndicateValueRequest {
    pub update: ValueChangedParameters,
    pub confirmation: fidl::EventPair,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RemoteServiceRegisterCharacteristicNotifierRequest {
    pub handle: Handle,
    pub notifier: fidl::endpoints::ClientEnd<CharacteristicNotifierMarker>,
}

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

#[derive(Debug, PartialEq)]
pub struct ServerPublishServiceRequest {
    pub info: ServiceInfo,
    pub service: fidl::endpoints::ClientEnd<LocalServiceMarker>,
}

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

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

impl fidl::endpoints::ProtocolMarker for CharacteristicNotifierMarker {
    type Proxy = CharacteristicNotifierProxy;
    type RequestStream = CharacteristicNotifierRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = CharacteristicNotifierSynchronousProxy;

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

pub trait CharacteristicNotifierProxyInterface: Send + Sync {
    type OnNotificationResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#on_notification(&self, value: &ReadValue) -> Self::OnNotificationResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct CharacteristicNotifierSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for CharacteristicNotifierSynchronousProxy {
    type Proxy = CharacteristicNotifierProxy;
    type Protocol = CharacteristicNotifierMarker;

    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 CharacteristicNotifierSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <CharacteristicNotifierMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

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

    /// Called when a characteristic value notification or indication is
    /// received from the server.
    ///
    /// + request `value` the value of the updated characteristic.
    /// - response An empty response should be sent immediately as an
    ///   acknowledgement that the notification was received (for flow control).
    pub fn r#on_notification(
        &self,
        mut value: &ReadValue,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            CharacteristicNotifierOnNotificationRequest,
            fidl::encoding::EmptyPayload,
        >(
            (value,),
            0x8edda1bd01f3c0a,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for CharacteristicNotifierProxy {
    type Protocol = CharacteristicNotifierMarker;

    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 CharacteristicNotifierProxy {
    /// Create a new Proxy for fuchsia.bluetooth.gatt2/CharacteristicNotifier.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <CharacteristicNotifierMarker 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) -> CharacteristicNotifierEventStream {
        CharacteristicNotifierEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Called when a characteristic value notification or indication is
    /// received from the server.
    ///
    /// + request `value` the value of the updated characteristic.
    /// - response An empty response should be sent immediately as an
    ///   acknowledgement that the notification was received (for flow control).
    pub fn r#on_notification(
        &self,
        mut value: &ReadValue,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        CharacteristicNotifierProxyInterface::r#on_notification(self, value)
    }
}

impl CharacteristicNotifierProxyInterface for CharacteristicNotifierProxy {
    type OnNotificationResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#on_notification(&self, mut value: &ReadValue) -> Self::OnNotificationResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x8edda1bd01f3c0a,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<CharacteristicNotifierOnNotificationRequest, ()>(
            (value,),
            0x8edda1bd01f3c0a,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for CharacteristicNotifierRequestStream {
    type Protocol = CharacteristicNotifierMarker;
    type ControlHandle = CharacteristicNotifierControlHandle;

    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 {
        CharacteristicNotifierControlHandle { 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 CharacteristicNotifierRequestStream {
    type Item = Result<CharacteristicNotifierRequest, 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 CharacteristicNotifierRequestStream 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 {
                0x8edda1bd01f3c0a => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(CharacteristicNotifierOnNotificationRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<CharacteristicNotifierOnNotificationRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = CharacteristicNotifierControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(CharacteristicNotifierRequest::OnNotification {value: req.value,

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

/// Listens to characteristic notifications & indications.
#[derive(Debug)]
pub enum CharacteristicNotifierRequest {
    /// Called when a characteristic value notification or indication is
    /// received from the server.
    ///
    /// + request `value` the value of the updated characteristic.
    /// - response An empty response should be sent immediately as an
    ///   acknowledgement that the notification was received (for flow control).
    OnNotification { value: ReadValue, responder: CharacteristicNotifierOnNotificationResponder },
}

impl CharacteristicNotifierRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_notification(
        self,
    ) -> Option<(ReadValue, CharacteristicNotifierOnNotificationResponder)> {
        if let CharacteristicNotifierRequest::OnNotification { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

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

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

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

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

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

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

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

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

#[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 WatchServicesResponseFut: std::future::Future<Output = Result<(Vec<ServiceInfo>, Vec<Handle>), fidl::Error>>
        + Send;
    fn r#watch_services(
        &self,
        uuids: &[fidl_fuchsia_bluetooth::Uuid],
    ) -> Self::WatchServicesResponseFut;
    fn r#connect_to_service(
        &self,
        handle: &ServiceHandle,
        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 {
        let protocol_name = <ClientMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

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

    /// Enumerates services found on the peer that this Client represents.
    ///
    /// Results can be filtered by specifying a list of UUIDs in `uuids`. This
    /// method follows the hanging get pattern. On the initial request, a
    /// complete snapshot will be returned. Subsequent calls with the same set
    /// of `uuids` receive a response only when one or more services have been
    /// added, modified, or removed from the entries reported since the most
    /// recent call. Calls with new values of `uuids` will reset the filter and
    /// receive a complete snapshot.
    ///
    /// Handles may be reused across services, so a handle may be in both
    /// `updated` and `removed`. For this reason, it is recommended to process
    /// removed services before updated services.
    ///
    /// To further interact with services, clients must obtain a RemoteService
    /// protocol by calling ConnectToService().
    ///
    /// + request `uuids` the UUID allowlist. If empty, all services will be
    ///   returned.
    /// - response `updated` the services that have been added or modified since
    ///   WatchServices() was last called. The returned ServiceInfo tables will
    ///   contain only basic information about each service and the
    ///   `characteristics` and `includes` fields will be null. If a service has
    ///   been added/modified and then removed since the last call, it will only
    ///   be present in `removed`, not `updated`.
    ///   If concluded due to a new call with a new `uuids` value, `updated`
    ///   will be empty.
    /// - response `removed` the handles of the services that have been removed
    ///   since the last call to WatchServices().
    pub fn r#watch_services(
        &self,
        mut uuids: &[fidl_fuchsia_bluetooth::Uuid],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(Vec<ServiceInfo>, Vec<Handle>), fidl::Error> {
        let _response =
            self.client.send_query::<ClientWatchServicesRequest, ClientWatchServicesResponse>(
                (uuids,),
                0x23243a22d6f08640,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok((_response.updated, _response.removed))
    }

    /// Connects the RemoteService with the given identifier. Only 1 connection
    /// per service is allowed.
    ///
    /// `service` will be closed on error, with an epitaph that provides a
    /// reason.
    /// * error Returns a `ZX_ERR_INVALID_ARGS` if `handle` is invalid.
    /// * error Returns a `ZX_ERR_NOT_FOUND` if the service is not found.
    /// * error Returns a `ZX_ERR_CONNECTION_RESET` if the service is removed.
    /// * error Returns a `ZX_ERR_NOT_CONNECTED` if the peer disconnects.
    /// * error Returns a `ZX_ERR_ALREADY_EXISTS` if the service is already connected.
    pub fn r#connect_to_service(
        &self,
        mut handle: &ServiceHandle,
        mut service: fidl::endpoints::ServerEnd<RemoteServiceMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<ClientConnectToServiceRequest>(
            (handle, service),
            0x61b59f2b6d075ff8,
            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.gatt2/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 filtered by specifying a list of UUIDs in `uuids`. This
    /// method follows the hanging get pattern. On the initial request, a
    /// complete snapshot will be returned. Subsequent calls with the same set
    /// of `uuids` receive a response only when one or more services have been
    /// added, modified, or removed from the entries reported since the most
    /// recent call. Calls with new values of `uuids` will reset the filter and
    /// receive a complete snapshot.
    ///
    /// Handles may be reused across services, so a handle may be in both
    /// `updated` and `removed`. For this reason, it is recommended to process
    /// removed services before updated services.
    ///
    /// To further interact with services, clients must obtain a RemoteService
    /// protocol by calling ConnectToService().
    ///
    /// + request `uuids` the UUID allowlist. If empty, all services will be
    ///   returned.
    /// - response `updated` the services that have been added or modified since
    ///   WatchServices() was last called. The returned ServiceInfo tables will
    ///   contain only basic information about each service and the
    ///   `characteristics` and `includes` fields will be null. If a service has
    ///   been added/modified and then removed since the last call, it will only
    ///   be present in `removed`, not `updated`.
    ///   If concluded due to a new call with a new `uuids` value, `updated`
    ///   will be empty.
    /// - response `removed` the handles of the services that have been removed
    ///   since the last call to WatchServices().
    pub fn r#watch_services(
        &self,
        mut uuids: &[fidl_fuchsia_bluetooth::Uuid],
    ) -> fidl::client::QueryResponseFut<
        (Vec<ServiceInfo>, Vec<Handle>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ClientProxyInterface::r#watch_services(self, uuids)
    }

    /// Connects the RemoteService with the given identifier. Only 1 connection
    /// per service is allowed.
    ///
    /// `service` will be closed on error, with an epitaph that provides a
    /// reason.
    /// * error Returns a `ZX_ERR_INVALID_ARGS` if `handle` is invalid.
    /// * error Returns a `ZX_ERR_NOT_FOUND` if the service is not found.
    /// * error Returns a `ZX_ERR_CONNECTION_RESET` if the service is removed.
    /// * error Returns a `ZX_ERR_NOT_CONNECTED` if the peer disconnects.
    /// * error Returns a `ZX_ERR_ALREADY_EXISTS` if the service is already connected.
    pub fn r#connect_to_service(
        &self,
        mut handle: &ServiceHandle,
        mut service: fidl::endpoints::ServerEnd<RemoteServiceMarker>,
    ) -> Result<(), fidl::Error> {
        ClientProxyInterface::r#connect_to_service(self, handle, service)
    }
}

impl ClientProxyInterface for ClientProxy {
    type WatchServicesResponseFut = fidl::client::QueryResponseFut<
        (Vec<ServiceInfo>, Vec<Handle>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#watch_services(
        &self,
        mut uuids: &[fidl_fuchsia_bluetooth::Uuid],
    ) -> Self::WatchServicesResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(Vec<ServiceInfo>, Vec<Handle>), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ClientWatchServicesResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x23243a22d6f08640,
            >(_buf?)?;
            Ok((_response.updated, _response.removed))
        }
        self.client
            .send_query_and_decode::<ClientWatchServicesRequest, (Vec<ServiceInfo>, Vec<Handle>)>(
                (uuids,),
                0x23243a22d6f08640,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    fn r#connect_to_service(
        &self,
        mut handle: &ServiceHandle,
        mut service: fidl::endpoints::ServerEnd<RemoteServiceMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<ClientConnectToServiceRequest>(
            (handle, service),
            0x61b59f2b6d075ff8,
            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.gatt2/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 {
                    0x23243a22d6f08640 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ClientWatchServicesRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ClientWatchServicesRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ClientControlHandle { inner: this.inner.clone() };
                        Ok(ClientRequest::WatchServices {
                            uuids: req.uuids,

                            responder: ClientWatchServicesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x61b59f2b6d075ff8 => {
                        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 {
                            handle: req.handle,
                            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 filtered by specifying a list of UUIDs in `uuids`. This
    /// method follows the hanging get pattern. On the initial request, a
    /// complete snapshot will be returned. Subsequent calls with the same set
    /// of `uuids` receive a response only when one or more services have been
    /// added, modified, or removed from the entries reported since the most
    /// recent call. Calls with new values of `uuids` will reset the filter and
    /// receive a complete snapshot.
    ///
    /// Handles may be reused across services, so a handle may be in both
    /// `updated` and `removed`. For this reason, it is recommended to process
    /// removed services before updated services.
    ///
    /// To further interact with services, clients must obtain a RemoteService
    /// protocol by calling ConnectToService().
    ///
    /// + request `uuids` the UUID allowlist. If empty, all services will be
    ///   returned.
    /// - response `updated` the services that have been added or modified since
    ///   WatchServices() was last called. The returned ServiceInfo tables will
    ///   contain only basic information about each service and the
    ///   `characteristics` and `includes` fields will be null. If a service has
    ///   been added/modified and then removed since the last call, it will only
    ///   be present in `removed`, not `updated`.
    ///   If concluded due to a new call with a new `uuids` value, `updated`
    ///   will be empty.
    /// - response `removed` the handles of the services that have been removed
    ///   since the last call to WatchServices().
    WatchServices {
        uuids: Vec<fidl_fuchsia_bluetooth::Uuid>,
        responder: ClientWatchServicesResponder,
    },
    /// Connects the RemoteService with the given identifier. Only 1 connection
    /// per service is allowed.
    ///
    /// `service` will be closed on error, with an epitaph that provides a
    /// reason.
    /// * error Returns a `ZX_ERR_INVALID_ARGS` if `handle` is invalid.
    /// * error Returns a `ZX_ERR_NOT_FOUND` if the service is not found.
    /// * error Returns a `ZX_ERR_CONNECTION_RESET` if the service is removed.
    /// * error Returns a `ZX_ERR_NOT_CONNECTED` if the peer disconnects.
    /// * error Returns a `ZX_ERR_ALREADY_EXISTS` if the service is already connected.
    ConnectToService {
        handle: ServiceHandle,
        service: fidl::endpoints::ServerEnd<RemoteServiceMarker>,
        control_handle: ClientControlHandle,
    },
}

impl ClientRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_watch_services(
        self,
    ) -> Option<(Vec<fidl_fuchsia_bluetooth::Uuid>, ClientWatchServicesResponder)> {
        if let ClientRequest::WatchServices { uuids, responder } = self {
            Some((uuids, responder))
        } else {
            None
        }
    }

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

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            ClientRequest::WatchServices { .. } => "watch_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 ClientWatchServicesResponder {
    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 ClientWatchServicesResponder {
    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 ClientWatchServicesResponder {
    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 ClientWatchServicesResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut updated: &[ServiceInfo],
        mut removed: &[Handle],
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(updated, removed);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

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

    fn send_raw(
        &self,
        mut updated: &[ServiceInfo],
        mut removed: &[Handle],
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<ClientWatchServicesResponse>(
            (updated, removed),
            self.tx_id,
            0x23243a22d6f08640,
            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 type LocalServiceReadValueResult = Result<Vec<u8>, Error>;
pub type LocalServiceWriteValueResult = Result<(), Error>;

pub trait LocalServiceProxyInterface: Send + Sync {
    type CharacteristicConfigurationResponseFut: std::future::Future<Output = Result<(), fidl::Error>>
        + Send;
    fn r#characteristic_configuration(
        &self,
        peer_id: &fidl_fuchsia_bluetooth::PeerId,
        handle: &Handle,
        notify: bool,
        indicate: bool,
    ) -> Self::CharacteristicConfigurationResponseFut;
    type ReadValueResponseFut: std::future::Future<Output = Result<LocalServiceReadValueResult, fidl::Error>>
        + Send;
    fn r#read_value(
        &self,
        peer_id: &fidl_fuchsia_bluetooth::PeerId,
        handle: &Handle,
        offset: i32,
    ) -> Self::ReadValueResponseFut;
    type WriteValueResponseFut: std::future::Future<Output = Result<LocalServiceWriteValueResult, fidl::Error>>
        + Send;
    fn r#write_value(&self, payload: &LocalServiceWriteValueRequest)
    -> Self::WriteValueResponseFut;
    type PeerUpdateResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#peer_update(&self, payload: &LocalServicePeerUpdateRequest)
    -> Self::PeerUpdateResponseFut;
    fn r#value_changed_credit(&self, additional_credit: u8) -> 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 {
        let protocol_name = <LocalServiceMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

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

    /// This notifies the current configuration of a particular characteristic/descriptor for a
    /// particular peer. It will be called when the peer GATT client changes the configuration.
    ///
    /// The Bluetooth stack maintains the state of each peer's configuration across reconnections.
    /// As such, this method will also be called when a peer connects for each characteristic with
    /// the initial, persisted state of the newly-connected peer's configuration. However, clients
    /// should not rely on this state being persisted indefinitely by the Bluetooth stack.
    ///
    /// + request `peer_id` The PeerId of the GATT client associated with this particular CCC.
    /// + request `handle` The handle of the characteristic associated with the `notify` and
    ///  `indicate` parameters.
    /// + request `notify` True if the client has enabled notifications, false otherwise.
    /// + request `indicate` True if the client has enabled indications, false otherwise.
    /// - response empty Returns nothing to acknowledge the characteristic configuration.
    pub fn r#characteristic_configuration(
        &self,
        mut peer_id: &fidl_fuchsia_bluetooth::PeerId,
        mut handle: &Handle,
        mut notify: bool,
        mut indicate: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            LocalServiceCharacteristicConfigurationRequest,
            fidl::encoding::EmptyPayload,
        >(
            (peer_id, handle, notify, indicate,),
            0x431101fcd8d9ef15,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    /// Called when a peer requests to read the value of a characteristic or descriptor. It is
    /// guaranteed that the peer satisfies the permssions associated with this attribute.
    ///
    /// + request `peer_id` The PeerId of the GATT client making the read request.
    /// + request `handle` The handle of the requested descriptor/characteristic.
    /// + request `offset` The offset at which to start reading the requested value.
    /// - response `value` The value of the characteristic.
    /// * error See `gatt2.Error` documentation for possible errors.
    pub fn r#read_value(
        &self,
        mut peer_id: &fidl_fuchsia_bluetooth::PeerId,
        mut handle: &Handle,
        mut offset: i32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<LocalServiceReadValueResult, fidl::Error> {
        let _response = self.client.send_query::<
            LocalServiceReadValueRequest,
            fidl::encoding::ResultType<LocalServiceReadValueResponse, Error>,
        >(
            (peer_id, handle, offset,),
            0x49e11d396625d104,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.value))
    }

    /// Called when a peer issues a request to write the value of a characteristic or descriptor. It
    /// is guaranteed that the peer satisfies the permissions associated with this attribute.
    ///
    /// + request `peer_id` The PeerId of the GATT client making the write request. Always present.
    /// + request `handle` The handle of the requested descriptor/characteristic. Always present.
    /// + request `offset` The offset at which to start writing the value. If the offset is 0, any
    ///   existing value should be overwritten by the new value. Otherwise, the existing value from
    ///   offset:(offset + len(value)) should be changed to `value`. Always present.
    /// + request `value` The new value for the descriptor/characteristic. Always present, but may
    ///   be the empty string.
    /// - response  The implementation must send an empty response once the value has been updated
    ///   as confirmation.
    /// * error See `gatt2.Error` documentation for possible errors.
    pub fn r#write_value(
        &self,
        mut payload: &LocalServiceWriteValueRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<LocalServiceWriteValueResult, fidl::Error> {
        let _response = self.client.send_query::<
            LocalServiceWriteValueRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
        >(
            payload,
            0x7d6ae631baf18260,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Called to provide GATT information specific to a peer. PeerUpdate will not be called unless
    /// the prior invocation received a response. As such, the implementation can simply ignore the
    /// first invocation if they are not interested in any PeerUpdate fields.
    ///
    /// A PeerUpdate will be made before propagating any other interaction from the peer to the
    /// LocalService (Write/ReadValue, CharacteristicConfiguration) on a best-effort basis, as long
    /// as all preceding PeerUpdates were acknowledged.
    ///
    /// Not currently sent. Comment on https://fxbug.dev/42178509 to request support
    ///
    /// + request `peer_id` The PeerId the update pertains to. Always present.
    /// + request `mtu` The maximum number of bytes that fit in a notification/indication to this
    ///   peer. Any bytes past this limit are silently truncated. Most clients need not concern
    ///   themselves with this unless they are using notifications/indications for high throughput.
    ///   Optional.
    /// - response An empty response to acknowledge that the update was received.
    pub fn r#peer_update(
        &self,
        mut payload: &LocalServicePeerUpdateRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response =
            self.client.send_query::<LocalServicePeerUpdateRequest, fidl::encoding::EmptyPayload>(
                payload,
                0x7e362177a04108b8,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    /// Add credit for sending indications/notifications. Implementors are defined to start out with
    /// INITIAL_VALUE_CHANGED_CREDITS credits before this method is called. Implementors must keep
    /// track of the available credit they have. The implementor can send exactly one OnNotifyValue
    /// or OnIndicateValue event for each credit. Note that `ValueChangedCredit` will only be called
    /// if at least one indication/notification has been sent since the prior call.
    pub fn r#value_changed_credit(&self, mut additional_credit: u8) -> Result<(), fidl::Error> {
        self.client.send::<LocalServiceValueChangedCreditRequest>(
            (additional_credit,),
            0x7cf0931548318566,
            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.gatt2/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() }
    }

    /// This notifies the current configuration of a particular characteristic/descriptor for a
    /// particular peer. It will be called when the peer GATT client changes the configuration.
    ///
    /// The Bluetooth stack maintains the state of each peer's configuration across reconnections.
    /// As such, this method will also be called when a peer connects for each characteristic with
    /// the initial, persisted state of the newly-connected peer's configuration. However, clients
    /// should not rely on this state being persisted indefinitely by the Bluetooth stack.
    ///
    /// + request `peer_id` The PeerId of the GATT client associated with this particular CCC.
    /// + request `handle` The handle of the characteristic associated with the `notify` and
    ///  `indicate` parameters.
    /// + request `notify` True if the client has enabled notifications, false otherwise.
    /// + request `indicate` True if the client has enabled indications, false otherwise.
    /// - response empty Returns nothing to acknowledge the characteristic configuration.
    pub fn r#characteristic_configuration(
        &self,
        mut peer_id: &fidl_fuchsia_bluetooth::PeerId,
        mut handle: &Handle,
        mut notify: bool,
        mut indicate: bool,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        LocalServiceProxyInterface::r#characteristic_configuration(
            self, peer_id, handle, notify, indicate,
        )
    }

    /// Called when a peer requests to read the value of a characteristic or descriptor. It is
    /// guaranteed that the peer satisfies the permssions associated with this attribute.
    ///
    /// + request `peer_id` The PeerId of the GATT client making the read request.
    /// + request `handle` The handle of the requested descriptor/characteristic.
    /// + request `offset` The offset at which to start reading the requested value.
    /// - response `value` The value of the characteristic.
    /// * error See `gatt2.Error` documentation for possible errors.
    pub fn r#read_value(
        &self,
        mut peer_id: &fidl_fuchsia_bluetooth::PeerId,
        mut handle: &Handle,
        mut offset: i32,
    ) -> fidl::client::QueryResponseFut<
        LocalServiceReadValueResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        LocalServiceProxyInterface::r#read_value(self, peer_id, handle, offset)
    }

    /// Called when a peer issues a request to write the value of a characteristic or descriptor. It
    /// is guaranteed that the peer satisfies the permissions associated with this attribute.
    ///
    /// + request `peer_id` The PeerId of the GATT client making the write request. Always present.
    /// + request `handle` The handle of the requested descriptor/characteristic. Always present.
    /// + request `offset` The offset at which to start writing the value. If the offset is 0, any
    ///   existing value should be overwritten by the new value. Otherwise, the existing value from
    ///   offset:(offset + len(value)) should be changed to `value`. Always present.
    /// + request `value` The new value for the descriptor/characteristic. Always present, but may
    ///   be the empty string.
    /// - response  The implementation must send an empty response once the value has been updated
    ///   as confirmation.
    /// * error See `gatt2.Error` documentation for possible errors.
    pub fn r#write_value(
        &self,
        mut payload: &LocalServiceWriteValueRequest,
    ) -> fidl::client::QueryResponseFut<
        LocalServiceWriteValueResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        LocalServiceProxyInterface::r#write_value(self, payload)
    }

    /// Called to provide GATT information specific to a peer. PeerUpdate will not be called unless
    /// the prior invocation received a response. As such, the implementation can simply ignore the
    /// first invocation if they are not interested in any PeerUpdate fields.
    ///
    /// A PeerUpdate will be made before propagating any other interaction from the peer to the
    /// LocalService (Write/ReadValue, CharacteristicConfiguration) on a best-effort basis, as long
    /// as all preceding PeerUpdates were acknowledged.
    ///
    /// Not currently sent. Comment on https://fxbug.dev/42178509 to request support
    ///
    /// + request `peer_id` The PeerId the update pertains to. Always present.
    /// + request `mtu` The maximum number of bytes that fit in a notification/indication to this
    ///   peer. Any bytes past this limit are silently truncated. Most clients need not concern
    ///   themselves with this unless they are using notifications/indications for high throughput.
    ///   Optional.
    /// - response An empty response to acknowledge that the update was received.
    pub fn r#peer_update(
        &self,
        mut payload: &LocalServicePeerUpdateRequest,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        LocalServiceProxyInterface::r#peer_update(self, payload)
    }

    /// Add credit for sending indications/notifications. Implementors are defined to start out with
    /// INITIAL_VALUE_CHANGED_CREDITS credits before this method is called. Implementors must keep
    /// track of the available credit they have. The implementor can send exactly one OnNotifyValue
    /// or OnIndicateValue event for each credit. Note that `ValueChangedCredit` will only be called
    /// if at least one indication/notification has been sent since the prior call.
    pub fn r#value_changed_credit(&self, mut additional_credit: u8) -> Result<(), fidl::Error> {
        LocalServiceProxyInterface::r#value_changed_credit(self, additional_credit)
    }
}

impl LocalServiceProxyInterface for LocalServiceProxy {
    type CharacteristicConfigurationResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#characteristic_configuration(
        &self,
        mut peer_id: &fidl_fuchsia_bluetooth::PeerId,
        mut handle: &Handle,
        mut notify: bool,
        mut indicate: bool,
    ) -> Self::CharacteristicConfigurationResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x431101fcd8d9ef15,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<LocalServiceCharacteristicConfigurationRequest, ()>(
            (peer_id, handle, notify, indicate),
            0x431101fcd8d9ef15,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ReadValueResponseFut = fidl::client::QueryResponseFut<
        LocalServiceReadValueResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#read_value(
        &self,
        mut peer_id: &fidl_fuchsia_bluetooth::PeerId,
        mut handle: &Handle,
        mut offset: i32,
    ) -> Self::ReadValueResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<LocalServiceReadValueResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<LocalServiceReadValueResponse, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x49e11d396625d104,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<LocalServiceReadValueRequest, LocalServiceReadValueResult>(
                (peer_id, handle, offset),
                0x49e11d396625d104,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

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

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

    fn r#value_changed_credit(&self, mut additional_credit: u8) -> Result<(), fidl::Error> {
        self.client.send::<LocalServiceValueChangedCreditRequest>(
            (additional_credit,),
            0x7cf0931548318566,
            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 {
    OnSuppressDiscovery {},
    OnNotifyValue { payload: ValueChangedParameters },
    OnIndicateValue { update: ValueChangedParameters, confirmation: fidl::EventPair },
}

impl LocalServiceEvent {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_suppress_discovery(self) -> Option<()> {
        if let LocalServiceEvent::OnSuppressDiscovery {} = self { Some(()) } else { None }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_notify_value(self) -> Option<ValueChangedParameters> {
        if let LocalServiceEvent::OnNotifyValue { payload } = self { Some((payload)) } else { None }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_indicate_value(self) -> Option<(ValueChangedParameters, fidl::EventPair)> {
        if let LocalServiceEvent::OnIndicateValue { update, confirmation } = self {
            Some((update, confirmation))
        } else {
            None
        }
    }

    /// 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 {
            0x106d36281c3cfb66 => {
                let mut out = fidl::new_empty!(
                    fidl::encoding::EmptyPayload,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((LocalServiceEvent::OnSuppressDiscovery {}))
            }
            0x190c1c528bfd0068 => {
                let mut out = fidl::new_empty!(
                    ValueChangedParameters,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ValueChangedParameters>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((LocalServiceEvent::OnNotifyValue { payload: out }))
            }
            0x59431c3653ac531f => {
                let mut out = fidl::new_empty!(
                    LocalServiceOnIndicateValueRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<LocalServiceOnIndicateValueRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((LocalServiceEvent::OnIndicateValue {
                    update: out.update,
                    confirmation: out.confirmation,
                }))
            }
            _ => 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.gatt2/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 {
                    0x431101fcd8d9ef15 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            LocalServiceCharacteristicConfigurationRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<LocalServiceCharacteristicConfigurationRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            LocalServiceControlHandle { inner: this.inner.clone() };
                        Ok(LocalServiceRequest::CharacteristicConfiguration {
                            peer_id: req.peer_id,
                            handle: req.handle,
                            notify: req.notify,
                            indicate: req.indicate,

                            responder: LocalServiceCharacteristicConfigurationResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x49e11d396625d104 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            LocalServiceReadValueRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<LocalServiceReadValueRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            LocalServiceControlHandle { inner: this.inner.clone() };
                        Ok(LocalServiceRequest::ReadValue {
                            peer_id: req.peer_id,
                            handle: req.handle,
                            offset: req.offset,

                            responder: LocalServiceReadValueResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7d6ae631baf18260 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            LocalServiceWriteValueRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<LocalServiceWriteValueRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            LocalServiceControlHandle { inner: this.inner.clone() };
                        Ok(LocalServiceRequest::WriteValue {
                            payload: req,
                            responder: LocalServiceWriteValueResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7e362177a04108b8 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            LocalServicePeerUpdateRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<LocalServicePeerUpdateRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            LocalServiceControlHandle { inner: this.inner.clone() };
                        Ok(LocalServiceRequest::PeerUpdate {
                            payload: req,
                            responder: LocalServicePeerUpdateResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7cf0931548318566 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            LocalServiceValueChangedCreditRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<LocalServiceValueChangedCreditRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            LocalServiceControlHandle { inner: this.inner.clone() };
                        Ok(LocalServiceRequest::ValueChangedCredit {
                            additional_credit: req.additional_credit,

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

/// Interface for serving a local GATT service. Closing the server_end of this protocol causes the
/// GATT service to be removed from the local GATT database. Similarly, closure of the client_end
/// of this protocol means the Bluetooth stack has removed this service from its GATT database.
#[derive(Debug)]
pub enum LocalServiceRequest {
    /// This notifies the current configuration of a particular characteristic/descriptor for a
    /// particular peer. It will be called when the peer GATT client changes the configuration.
    ///
    /// The Bluetooth stack maintains the state of each peer's configuration across reconnections.
    /// As such, this method will also be called when a peer connects for each characteristic with
    /// the initial, persisted state of the newly-connected peer's configuration. However, clients
    /// should not rely on this state being persisted indefinitely by the Bluetooth stack.
    ///
    /// + request `peer_id` The PeerId of the GATT client associated with this particular CCC.
    /// + request `handle` The handle of the characteristic associated with the `notify` and
    ///  `indicate` parameters.
    /// + request `notify` True if the client has enabled notifications, false otherwise.
    /// + request `indicate` True if the client has enabled indications, false otherwise.
    /// - response empty Returns nothing to acknowledge the characteristic configuration.
    CharacteristicConfiguration {
        peer_id: fidl_fuchsia_bluetooth::PeerId,
        handle: Handle,
        notify: bool,
        indicate: bool,
        responder: LocalServiceCharacteristicConfigurationResponder,
    },
    /// Called when a peer requests to read the value of a characteristic or descriptor. It is
    /// guaranteed that the peer satisfies the permssions associated with this attribute.
    ///
    /// + request `peer_id` The PeerId of the GATT client making the read request.
    /// + request `handle` The handle of the requested descriptor/characteristic.
    /// + request `offset` The offset at which to start reading the requested value.
    /// - response `value` The value of the characteristic.
    /// * error See `gatt2.Error` documentation for possible errors.
    ReadValue {
        peer_id: fidl_fuchsia_bluetooth::PeerId,
        handle: Handle,
        offset: i32,
        responder: LocalServiceReadValueResponder,
    },
    /// Called when a peer issues a request to write the value of a characteristic or descriptor. It
    /// is guaranteed that the peer satisfies the permissions associated with this attribute.
    ///
    /// + request `peer_id` The PeerId of the GATT client making the write request. Always present.
    /// + request `handle` The handle of the requested descriptor/characteristic. Always present.
    /// + request `offset` The offset at which to start writing the value. If the offset is 0, any
    ///   existing value should be overwritten by the new value. Otherwise, the existing value from
    ///   offset:(offset + len(value)) should be changed to `value`. Always present.
    /// + request `value` The new value for the descriptor/characteristic. Always present, but may
    ///   be the empty string.
    /// - response  The implementation must send an empty response once the value has been updated
    ///   as confirmation.
    /// * error See `gatt2.Error` documentation for possible errors.
    WriteValue {
        payload: LocalServiceWriteValueRequest,
        responder: LocalServiceWriteValueResponder,
    },
    /// Called to provide GATT information specific to a peer. PeerUpdate will not be called unless
    /// the prior invocation received a response. As such, the implementation can simply ignore the
    /// first invocation if they are not interested in any PeerUpdate fields.
    ///
    /// A PeerUpdate will be made before propagating any other interaction from the peer to the
    /// LocalService (Write/ReadValue, CharacteristicConfiguration) on a best-effort basis, as long
    /// as all preceding PeerUpdates were acknowledged.
    ///
    /// Not currently sent. Comment on https://fxbug.dev/42178509 to request support
    ///
    /// + request `peer_id` The PeerId the update pertains to. Always present.
    /// + request `mtu` The maximum number of bytes that fit in a notification/indication to this
    ///   peer. Any bytes past this limit are silently truncated. Most clients need not concern
    ///   themselves with this unless they are using notifications/indications for high throughput.
    ///   Optional.
    /// - response An empty response to acknowledge that the update was received.
    PeerUpdate {
        payload: LocalServicePeerUpdateRequest,
        responder: LocalServicePeerUpdateResponder,
    },
    /// Add credit for sending indications/notifications. Implementors are defined to start out with
    /// INITIAL_VALUE_CHANGED_CREDITS credits before this method is called. Implementors must keep
    /// track of the available credit they have. The implementor can send exactly one OnNotifyValue
    /// or OnIndicateValue event for each credit. Note that `ValueChangedCredit` will only be called
    /// if at least one indication/notification has been sent since the prior call.
    ValueChangedCredit { additional_credit: u8, control_handle: LocalServiceControlHandle },
}

impl LocalServiceRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_characteristic_configuration(
        self,
    ) -> Option<(
        fidl_fuchsia_bluetooth::PeerId,
        Handle,
        bool,
        bool,
        LocalServiceCharacteristicConfigurationResponder,
    )> {
        if let LocalServiceRequest::CharacteristicConfiguration {
            peer_id,
            handle,
            notify,
            indicate,
            responder,
        } = self
        {
            Some((peer_id, handle, notify, indicate, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_read_value(
        self,
    ) -> Option<(fidl_fuchsia_bluetooth::PeerId, Handle, i32, LocalServiceReadValueResponder)> {
        if let LocalServiceRequest::ReadValue { peer_id, handle, offset, responder } = self {
            Some((peer_id, handle, offset, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_write_value(
        self,
    ) -> Option<(LocalServiceWriteValueRequest, LocalServiceWriteValueResponder)> {
        if let LocalServiceRequest::WriteValue { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_peer_update(
        self,
    ) -> Option<(LocalServicePeerUpdateRequest, LocalServicePeerUpdateResponder)> {
        if let LocalServiceRequest::PeerUpdate { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_value_changed_credit(self) -> Option<(u8, LocalServiceControlHandle)> {
        if let LocalServiceRequest::ValueChangedCredit { additional_credit, control_handle } = self
        {
            Some((additional_credit, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            LocalServiceRequest::CharacteristicConfiguration { .. } => {
                "characteristic_configuration"
            }
            LocalServiceRequest::ReadValue { .. } => "read_value",
            LocalServiceRequest::WriteValue { .. } => "write_value",
            LocalServiceRequest::PeerUpdate { .. } => "peer_update",
            LocalServiceRequest::ValueChangedCredit { .. } => "value_changed_credit",
        }
    }
}

#[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 {
    pub fn send_on_suppress_discovery(&self) -> Result<(), fidl::Error> {
        self.inner.send::<fidl::encoding::EmptyPayload>(
            (),
            0,
            0x106d36281c3cfb66,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_on_notify_value(
        &self,
        mut payload: &ValueChangedParameters,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<ValueChangedParameters>(
            payload,
            0,
            0x190c1c528bfd0068,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_on_indicate_value(
        &self,
        mut update: &ValueChangedParameters,
        mut confirmation: fidl::EventPair,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<LocalServiceOnIndicateValueRequest>(
            (update, confirmation),
            0,
            0x59431c3653ac531f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    fn send_raw(&self) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
            (),
            self.tx_id,
            0x7e362177a04108b8,
            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 type RemoteServiceReadCharacteristicResult = Result<ReadValue, Error>;
pub type RemoteServiceWriteCharacteristicResult = Result<(), Error>;
pub type RemoteServiceReadDescriptorResult = Result<ReadValue, Error>;
pub type RemoteServiceWriteDescriptorResult = Result<(), Error>;
pub type RemoteServiceRegisterCharacteristicNotifierResult = Result<(), Error>;

pub trait RemoteServiceProxyInterface: Send + Sync {
    type DiscoverCharacteristicsResponseFut: std::future::Future<Output = Result<Vec<Characteristic>, fidl::Error>>
        + Send;
    fn r#discover_characteristics(&self) -> Self::DiscoverCharacteristicsResponseFut;
    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 ReadCharacteristicResponseFut: std::future::Future<Output = Result<RemoteServiceReadCharacteristicResult, fidl::Error>>
        + Send;
    fn r#read_characteristic(
        &self,
        handle: &Handle,
        options: &ReadOptions,
    ) -> Self::ReadCharacteristicResponseFut;
    type WriteCharacteristicResponseFut: std::future::Future<Output = Result<RemoteServiceWriteCharacteristicResult, fidl::Error>>
        + Send;
    fn r#write_characteristic(
        &self,
        handle: &Handle,
        value: &[u8],
        options: &WriteOptions,
    ) -> Self::WriteCharacteristicResponseFut;
    type ReadDescriptorResponseFut: std::future::Future<Output = Result<RemoteServiceReadDescriptorResult, fidl::Error>>
        + Send;
    fn r#read_descriptor(
        &self,
        handle: &Handle,
        options: &ReadOptions,
    ) -> Self::ReadDescriptorResponseFut;
    type WriteDescriptorResponseFut: std::future::Future<Output = Result<RemoteServiceWriteDescriptorResult, fidl::Error>>
        + Send;
    fn r#write_descriptor(
        &self,
        handle: &Handle,
        value: &[u8],
        options: &WriteOptions,
    ) -> Self::WriteDescriptorResponseFut;
    type RegisterCharacteristicNotifierResponseFut: std::future::Future<
            Output = Result<RemoteServiceRegisterCharacteristicNotifierResult, fidl::Error>,
        > + Send;
    fn r#register_characteristic_notifier(
        &self,
        handle: &Handle,
        notifier: fidl::endpoints::ClientEnd<CharacteristicNotifierMarker>,
    ) -> Self::RegisterCharacteristicNotifierResponseFut;
}
#[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 {
        let protocol_name = <RemoteServiceMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

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

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

    /// Reads characteristics and descriptors with the given `uuid`.
    ///
    /// This method is useful for reading values before discovery has completed,
    /// thereby reducing latency.
    ///
    /// + request `uuid` The UUID of the characteristics/descriptors to read.
    /// - response `results` The results of the read. May be empty if no
    ///            matching values are read. If reading a value results in a
    ///            permission error, the handle and error will be included.
    /// * error Returns `INVALID_PARAMETERS` if `uuid` refers to an internally
    ///         reserved descriptor type (e.g. the Client Characteristic
    ///         Configuration descriptor).
    /// * error Returns `TOO_MANY_RESULTS` if more results were read than can fit
    ///         in a FIDL response. Consider reading characteristics/descriptors
    ///         individually after performing discovery.
    /// * error Returns `FAILURE` if the server returns an error not specific to
    ///         a single result.
    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>,
        >(
            (uuid,),
            0x739bb1e313162bbc,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.results))
    }

    /// Reads the value of a characteristic with the given `handle`.
    ///
    /// + request `handle` The characteristic handle to read.
    /// + request `options` Options that apply to the read.
    /// - response `value` The value of the characteristic.
    /// * error Returns `INVALID_HANDLE` if `handle` is invalid.
    /// * error Returns `INVALID_PARAMETERS` if `options` is invalid.
    /// * error Returns `READ_NOT_PERMITTED` or `INSUFFICIENT_*` if the server
    ///         rejects the read request.
    /// * error Returns `FAILURE` if the server returns an error.
    pub fn r#read_characteristic(
        &self,
        mut handle: &Handle,
        mut options: &ReadOptions,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RemoteServiceReadCharacteristicResult, fidl::Error> {
        let _response = self.client.send_query::<
            RemoteServiceReadCharacteristicRequest,
            fidl::encoding::ResultType<RemoteServiceReadCharacteristicResponse, Error>,
        >(
            (handle, options,),
            0x4d41757ed69a96cb,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.value))
    }

    /// Writes `value` to the characteristic with `handle` using the provided
    /// `options`.
    ///
    /// It is not recommended to send additional writes while a write is already
    /// in progress (the server may receive simultaneous writes in any order).
    ///
    /// + request `handle` The characteristic to be written to.
    /// + request `value` The value to be written.
    /// + request `options` Options that apply to the write.
    /// - response An empty response will be sent when a success response is
    ///            received from the server (or immediately if
    ///            `options.with_response` is false)
    /// * error Returns `INVALID_HANDLE` if `handle` is invalid.
    /// * error Returns `INVALID_PARAMETERS` if `options` is invalid.
    /// * error Returns `WRITE_NOT_PERMITTED` or `INSUFFICIENT_*`if the server
    ///         rejects the write request with a reason.
    /// * error Returns `FAILURE` if the server returns an error.
    pub fn r#write_characteristic(
        &self,
        mut handle: &Handle,
        mut value: &[u8],
        mut options: &WriteOptions,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RemoteServiceWriteCharacteristicResult, fidl::Error> {
        let _response = self.client.send_query::<
            RemoteServiceWriteCharacteristicRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
        >(
            (handle, value, options,),
            0x7fc7511adecde8c,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Reads the value of the characteristic descriptor with `handle` and
    /// returns it in the reply.
    ///
    /// + request `handle` The descriptor handle to read.
    /// + request `options` Options that apply to the read.
    /// - response `value` The value of the descriptor.
    /// * error Returns `INVALID_HANDLE` if `handle` is invalid.
    /// * error Returns `INVALID_PARAMETERS` if `options` is invalid.
    /// * error Returns `READ_NOT_PERMITTED` or `INSUFFICIENT_*` if the server
    ///         rejects the read request.
    /// * error Returns `FAILURE` if the server returns an error.
    pub fn r#read_descriptor(
        &self,
        mut handle: &Handle,
        mut options: &ReadOptions,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RemoteServiceReadDescriptorResult, fidl::Error> {
        let _response = self.client.send_query::<
            RemoteServiceReadDescriptorRequest,
            fidl::encoding::ResultType<RemoteServiceReadDescriptorResponse, Error>,
        >(
            (handle, options,),
            0x7ed7ce00457dcec1,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.value))
    }

    /// Writes `value` to the characteristic descriptor with `handle`.
    /// It is not recommended to send additional writes while a write is already
    /// in progress (the server may receive simultaneous writes in any order).
    ///
    /// + request `handle` The descriptor handle to written to.
    /// + request `value` The value to be written.
    /// + request `options` Options that apply to the write.
    /// - response An empty response will be sent when a success response is
    ///            received from the server (or immediately if
    ///            `options.with_response` is false)
    /// * error Returns `INVALID_HANDLE` if `handle` is invalid or refers to an
    ///         internally reserved descriptor type (e.g. the Client
    ///         Characteristic Configuration descriptor).
    /// * error Returns `INVALID_PARAMETERS` if `options` is invalid.
    /// * error Returns `WRITE_NOT_PERMITTED` or `INSUFFICIENT_*` if the server
    ///         rejects the write with a reason.
    /// * error Returns `FAILURE` if the server returns an error.
    pub fn r#write_descriptor(
        &self,
        mut handle: &Handle,
        mut value: &[u8],
        mut options: &WriteOptions,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RemoteServiceWriteDescriptorResult, fidl::Error> {
        let _response = self.client.send_query::<
            RemoteServiceWriteDescriptorRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
        >(
            (handle, value, options,),
            0x21d9106bfd6b7351,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Subscribe to notifications & indications from the characteristic with
    /// the given `handle`.
    ///
    /// 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 `notifier` protocol can be used to be notified when
    /// the peer sends a notification or indication. Indications are
    /// automatically confirmed. When the protocol is dropped, the subscription
    /// may end if no other local client is receiving notifications.
    ///
    /// + request `handle` the characteristic handle.
    /// + request `notifier` the protocol used for notifications.
    /// - response An empty response will be sent immediately if registration
    ///            succeeds.
    /// * error Returns a `FAILURE` if the characteristic does not support
    ///         notifications or indications.
    /// * error Returns a `INVALID_HANDLE` if `handle` is invalid.
    /// * error Returns a `WRITE_NOT_PERMITTED`  or `INSUFFICIENT_*`for a
    ///         descriptor write error.
    pub fn r#register_characteristic_notifier(
        &self,
        mut handle: &Handle,
        mut notifier: fidl::endpoints::ClientEnd<CharacteristicNotifierMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RemoteServiceRegisterCharacteristicNotifierResult, fidl::Error> {
        let _response = self.client.send_query::<
            RemoteServiceRegisterCharacteristicNotifierRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
        >(
            (handle, notifier,),
            0x35007a85245f5cc6,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

#[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.gatt2/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<
        Vec<Characteristic>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RemoteServiceProxyInterface::r#discover_characteristics(self)
    }

    /// Reads characteristics and descriptors with the given `uuid`.
    ///
    /// This method is useful for reading values before discovery has completed,
    /// thereby reducing latency.
    ///
    /// + request `uuid` The UUID of the characteristics/descriptors to read.
    /// - response `results` The results of the read. May be empty if no
    ///            matching values are read. If reading a value results in a
    ///            permission error, the handle and error will be included.
    /// * error Returns `INVALID_PARAMETERS` if `uuid` refers to an internally
    ///         reserved descriptor type (e.g. the Client Characteristic
    ///         Configuration descriptor).
    /// * error Returns `TOO_MANY_RESULTS` if more results were read than can fit
    ///         in a FIDL response. Consider reading characteristics/descriptors
    ///         individually after performing discovery.
    /// * error Returns `FAILURE` if the server returns an error not specific to
    ///         a single result.
    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)
    }

    /// Reads the value of a characteristic with the given `handle`.
    ///
    /// + request `handle` The characteristic handle to read.
    /// + request `options` Options that apply to the read.
    /// - response `value` The value of the characteristic.
    /// * error Returns `INVALID_HANDLE` if `handle` is invalid.
    /// * error Returns `INVALID_PARAMETERS` if `options` is invalid.
    /// * error Returns `READ_NOT_PERMITTED` or `INSUFFICIENT_*` if the server
    ///         rejects the read request.
    /// * error Returns `FAILURE` if the server returns an error.
    pub fn r#read_characteristic(
        &self,
        mut handle: &Handle,
        mut options: &ReadOptions,
    ) -> fidl::client::QueryResponseFut<
        RemoteServiceReadCharacteristicResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RemoteServiceProxyInterface::r#read_characteristic(self, handle, options)
    }

    /// Writes `value` to the characteristic with `handle` using the provided
    /// `options`.
    ///
    /// It is not recommended to send additional writes while a write is already
    /// in progress (the server may receive simultaneous writes in any order).
    ///
    /// + request `handle` The characteristic to be written to.
    /// + request `value` The value to be written.
    /// + request `options` Options that apply to the write.
    /// - response An empty response will be sent when a success response is
    ///            received from the server (or immediately if
    ///            `options.with_response` is false)
    /// * error Returns `INVALID_HANDLE` if `handle` is invalid.
    /// * error Returns `INVALID_PARAMETERS` if `options` is invalid.
    /// * error Returns `WRITE_NOT_PERMITTED` or `INSUFFICIENT_*`if the server
    ///         rejects the write request with a reason.
    /// * error Returns `FAILURE` if the server returns an error.
    pub fn r#write_characteristic(
        &self,
        mut handle: &Handle,
        mut value: &[u8],
        mut options: &WriteOptions,
    ) -> fidl::client::QueryResponseFut<
        RemoteServiceWriteCharacteristicResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RemoteServiceProxyInterface::r#write_characteristic(self, handle, value, options)
    }

    /// Reads the value of the characteristic descriptor with `handle` and
    /// returns it in the reply.
    ///
    /// + request `handle` The descriptor handle to read.
    /// + request `options` Options that apply to the read.
    /// - response `value` The value of the descriptor.
    /// * error Returns `INVALID_HANDLE` if `handle` is invalid.
    /// * error Returns `INVALID_PARAMETERS` if `options` is invalid.
    /// * error Returns `READ_NOT_PERMITTED` or `INSUFFICIENT_*` if the server
    ///         rejects the read request.
    /// * error Returns `FAILURE` if the server returns an error.
    pub fn r#read_descriptor(
        &self,
        mut handle: &Handle,
        mut options: &ReadOptions,
    ) -> fidl::client::QueryResponseFut<
        RemoteServiceReadDescriptorResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RemoteServiceProxyInterface::r#read_descriptor(self, handle, options)
    }

    /// Writes `value` to the characteristic descriptor with `handle`.
    /// It is not recommended to send additional writes while a write is already
    /// in progress (the server may receive simultaneous writes in any order).
    ///
    /// + request `handle` The descriptor handle to written to.
    /// + request `value` The value to be written.
    /// + request `options` Options that apply to the write.
    /// - response An empty response will be sent when a success response is
    ///            received from the server (or immediately if
    ///            `options.with_response` is false)
    /// * error Returns `INVALID_HANDLE` if `handle` is invalid or refers to an
    ///         internally reserved descriptor type (e.g. the Client
    ///         Characteristic Configuration descriptor).
    /// * error Returns `INVALID_PARAMETERS` if `options` is invalid.
    /// * error Returns `WRITE_NOT_PERMITTED` or `INSUFFICIENT_*` if the server
    ///         rejects the write with a reason.
    /// * error Returns `FAILURE` if the server returns an error.
    pub fn r#write_descriptor(
        &self,
        mut handle: &Handle,
        mut value: &[u8],
        mut options: &WriteOptions,
    ) -> fidl::client::QueryResponseFut<
        RemoteServiceWriteDescriptorResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RemoteServiceProxyInterface::r#write_descriptor(self, handle, value, options)
    }

    /// Subscribe to notifications & indications from the characteristic with
    /// the given `handle`.
    ///
    /// 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 `notifier` protocol can be used to be notified when
    /// the peer sends a notification or indication. Indications are
    /// automatically confirmed. When the protocol is dropped, the subscription
    /// may end if no other local client is receiving notifications.
    ///
    /// + request `handle` the characteristic handle.
    /// + request `notifier` the protocol used for notifications.
    /// - response An empty response will be sent immediately if registration
    ///            succeeds.
    /// * error Returns a `FAILURE` if the characteristic does not support
    ///         notifications or indications.
    /// * error Returns a `INVALID_HANDLE` if `handle` is invalid.
    /// * error Returns a `WRITE_NOT_PERMITTED`  or `INSUFFICIENT_*`for a
    ///         descriptor write error.
    pub fn r#register_characteristic_notifier(
        &self,
        mut handle: &Handle,
        mut notifier: fidl::endpoints::ClientEnd<CharacteristicNotifierMarker>,
    ) -> fidl::client::QueryResponseFut<
        RemoteServiceRegisterCharacteristicNotifierResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RemoteServiceProxyInterface::r#register_characteristic_notifier(self, handle, notifier)
    }
}

impl RemoteServiceProxyInterface for RemoteServiceProxy {
    type DiscoverCharacteristicsResponseFut = fidl::client::QueryResponseFut<
        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<Vec<Characteristic>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                RemoteServiceDiscoverCharacteristicsResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6cd730f12e402543,
            >(_buf?)?;
            Ok(_response.characteristics)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<Characteristic>>(
            (),
            0x6cd730f12e402543,
            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,
                0x739bb1e313162bbc,
            >(_buf?)?;
            Ok(_response.map(|x| x.results))
        }
        self.client
            .send_query_and_decode::<RemoteServiceReadByTypeRequest, RemoteServiceReadByTypeResult>(
                (uuid,),
                0x739bb1e313162bbc,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type ReadCharacteristicResponseFut = fidl::client::QueryResponseFut<
        RemoteServiceReadCharacteristicResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#read_characteristic(
        &self,
        mut handle: &Handle,
        mut options: &ReadOptions,
    ) -> Self::ReadCharacteristicResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RemoteServiceReadCharacteristicResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<RemoteServiceReadCharacteristicResponse, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4d41757ed69a96cb,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            RemoteServiceReadCharacteristicRequest,
            RemoteServiceReadCharacteristicResult,
        >(
            (handle, options,),
            0x4d41757ed69a96cb,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type WriteCharacteristicResponseFut = fidl::client::QueryResponseFut<
        RemoteServiceWriteCharacteristicResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#write_characteristic(
        &self,
        mut handle: &Handle,
        mut value: &[u8],
        mut options: &WriteOptions,
    ) -> Self::WriteCharacteristicResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RemoteServiceWriteCharacteristicResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7fc7511adecde8c,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            RemoteServiceWriteCharacteristicRequest,
            RemoteServiceWriteCharacteristicResult,
        >(
            (handle, value, options,),
            0x7fc7511adecde8c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ReadDescriptorResponseFut = fidl::client::QueryResponseFut<
        RemoteServiceReadDescriptorResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#read_descriptor(
        &self,
        mut handle: &Handle,
        mut options: &ReadOptions,
    ) -> Self::ReadDescriptorResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RemoteServiceReadDescriptorResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<RemoteServiceReadDescriptorResponse, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7ed7ce00457dcec1,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            RemoteServiceReadDescriptorRequest,
            RemoteServiceReadDescriptorResult,
        >(
            (handle, options,),
            0x7ed7ce00457dcec1,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type WriteDescriptorResponseFut = fidl::client::QueryResponseFut<
        RemoteServiceWriteDescriptorResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#write_descriptor(
        &self,
        mut handle: &Handle,
        mut value: &[u8],
        mut options: &WriteOptions,
    ) -> Self::WriteDescriptorResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RemoteServiceWriteDescriptorResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x21d9106bfd6b7351,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            RemoteServiceWriteDescriptorRequest,
            RemoteServiceWriteDescriptorResult,
        >(
            (handle, value, options,),
            0x21d9106bfd6b7351,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type RegisterCharacteristicNotifierResponseFut = fidl::client::QueryResponseFut<
        RemoteServiceRegisterCharacteristicNotifierResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#register_characteristic_notifier(
        &self,
        mut handle: &Handle,
        mut notifier: fidl::endpoints::ClientEnd<CharacteristicNotifierMarker>,
    ) -> Self::RegisterCharacteristicNotifierResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RemoteServiceRegisterCharacteristicNotifierResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x35007a85245f5cc6,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            RemoteServiceRegisterCharacteristicNotifierRequest,
            RemoteServiceRegisterCharacteristicNotifierResult,
        >(
            (handle, notifier,),
            0x35007a85245f5cc6,
            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 {}

impl RemoteServiceEvent {
    /// 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 {
            _ => 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.gatt2/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 {
                    0x6cd730f12e402543 => {
                        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,
                            },
                        })
                    }
                    0x739bb1e313162bbc => {
                        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,
                            },
                        })
                    }
                    0x4d41757ed69a96cb => {
                        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 {
                            handle: req.handle,
                            options: req.options,

                            responder: RemoteServiceReadCharacteristicResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7fc7511adecde8c => {
                        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 {
                            handle: req.handle,
                            value: req.value,
                            options: req.options,

                            responder: RemoteServiceWriteCharacteristicResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7ed7ce00457dcec1 => {
                        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 {
                            handle: req.handle,
                            options: req.options,

                            responder: RemoteServiceReadDescriptorResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x21d9106bfd6b7351 => {
                        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 {
                            handle: req.handle,
                            value: req.value,
                            options: req.options,

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

                            responder: RemoteServiceRegisterCharacteristicNotifierResponder {
                                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 characteristics and descriptors with the given `uuid`.
    ///
    /// This method is useful for reading values before discovery has completed,
    /// thereby reducing latency.
    ///
    /// + request `uuid` The UUID of the characteristics/descriptors to read.
    /// - response `results` The results of the read. May be empty if no
    ///            matching values are read. If reading a value results in a
    ///            permission error, the handle and error will be included.
    /// * error Returns `INVALID_PARAMETERS` if `uuid` refers to an internally
    ///         reserved descriptor type (e.g. the Client Characteristic
    ///         Configuration descriptor).
    /// * error Returns `TOO_MANY_RESULTS` if more results were read than can fit
    ///         in a FIDL response. Consider reading characteristics/descriptors
    ///         individually after performing discovery.
    /// * error Returns `FAILURE` if the server returns an error not specific to
    ///         a single result.
    ReadByType { uuid: fidl_fuchsia_bluetooth::Uuid, responder: RemoteServiceReadByTypeResponder },
    /// Reads the value of a characteristic with the given `handle`.
    ///
    /// + request `handle` The characteristic handle to read.
    /// + request `options` Options that apply to the read.
    /// - response `value` The value of the characteristic.
    /// * error Returns `INVALID_HANDLE` if `handle` is invalid.
    /// * error Returns `INVALID_PARAMETERS` if `options` is invalid.
    /// * error Returns `READ_NOT_PERMITTED` or `INSUFFICIENT_*` if the server
    ///         rejects the read request.
    /// * error Returns `FAILURE` if the server returns an error.
    ReadCharacteristic {
        handle: Handle,
        options: ReadOptions,
        responder: RemoteServiceReadCharacteristicResponder,
    },
    /// Writes `value` to the characteristic with `handle` using the provided
    /// `options`.
    ///
    /// It is not recommended to send additional writes while a write is already
    /// in progress (the server may receive simultaneous writes in any order).
    ///
    /// + request `handle` The characteristic to be written to.
    /// + request `value` The value to be written.
    /// + request `options` Options that apply to the write.
    /// - response An empty response will be sent when a success response is
    ///            received from the server (or immediately if
    ///            `options.with_response` is false)
    /// * error Returns `INVALID_HANDLE` if `handle` is invalid.
    /// * error Returns `INVALID_PARAMETERS` if `options` is invalid.
    /// * error Returns `WRITE_NOT_PERMITTED` or `INSUFFICIENT_*`if the server
    ///         rejects the write request with a reason.
    /// * error Returns `FAILURE` if the server returns an error.
    WriteCharacteristic {
        handle: Handle,
        value: Vec<u8>,
        options: WriteOptions,
        responder: RemoteServiceWriteCharacteristicResponder,
    },
    /// Reads the value of the characteristic descriptor with `handle` and
    /// returns it in the reply.
    ///
    /// + request `handle` The descriptor handle to read.
    /// + request `options` Options that apply to the read.
    /// - response `value` The value of the descriptor.
    /// * error Returns `INVALID_HANDLE` if `handle` is invalid.
    /// * error Returns `INVALID_PARAMETERS` if `options` is invalid.
    /// * error Returns `READ_NOT_PERMITTED` or `INSUFFICIENT_*` if the server
    ///         rejects the read request.
    /// * error Returns `FAILURE` if the server returns an error.
    ReadDescriptor {
        handle: Handle,
        options: ReadOptions,
        responder: RemoteServiceReadDescriptorResponder,
    },
    /// Writes `value` to the characteristic descriptor with `handle`.
    /// It is not recommended to send additional writes while a write is already
    /// in progress (the server may receive simultaneous writes in any order).
    ///
    /// + request `handle` The descriptor handle to written to.
    /// + request `value` The value to be written.
    /// + request `options` Options that apply to the write.
    /// - response An empty response will be sent when a success response is
    ///            received from the server (or immediately if
    ///            `options.with_response` is false)
    /// * error Returns `INVALID_HANDLE` if `handle` is invalid or refers to an
    ///         internally reserved descriptor type (e.g. the Client
    ///         Characteristic Configuration descriptor).
    /// * error Returns `INVALID_PARAMETERS` if `options` is invalid.
    /// * error Returns `WRITE_NOT_PERMITTED` or `INSUFFICIENT_*` if the server
    ///         rejects the write with a reason.
    /// * error Returns `FAILURE` if the server returns an error.
    WriteDescriptor {
        handle: Handle,
        value: Vec<u8>,
        options: WriteOptions,
        responder: RemoteServiceWriteDescriptorResponder,
    },
    /// Subscribe to notifications & indications from the characteristic with
    /// the given `handle`.
    ///
    /// 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 `notifier` protocol can be used to be notified when
    /// the peer sends a notification or indication. Indications are
    /// automatically confirmed. When the protocol is dropped, the subscription
    /// may end if no other local client is receiving notifications.
    ///
    /// + request `handle` the characteristic handle.
    /// + request `notifier` the protocol used for notifications.
    /// - response An empty response will be sent immediately if registration
    ///            succeeds.
    /// * error Returns a `FAILURE` if the characteristic does not support
    ///         notifications or indications.
    /// * error Returns a `INVALID_HANDLE` if `handle` is invalid.
    /// * error Returns a `WRITE_NOT_PERMITTED`  or `INSUFFICIENT_*`for a
    ///         descriptor write error.
    RegisterCharacteristicNotifier {
        handle: Handle,
        notifier: fidl::endpoints::ClientEnd<CharacteristicNotifierMarker>,
        responder: RemoteServiceRegisterCharacteristicNotifierResponder,
    },
}

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_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_read_characteristic(
        self,
    ) -> Option<(Handle, ReadOptions, RemoteServiceReadCharacteristicResponder)> {
        if let RemoteServiceRequest::ReadCharacteristic { handle, options, responder } = self {
            Some((handle, options, responder))
        } else {
            None
        }
    }

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

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

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_register_characteristic_notifier(
        self,
    ) -> Option<(
        Handle,
        fidl::endpoints::ClientEnd<CharacteristicNotifierMarker>,
        RemoteServiceRegisterCharacteristicNotifierResponder,
    )> {
        if let RemoteServiceRequest::RegisterCharacteristicNotifier {
            handle,
            notifier,
            responder,
        } = self
        {
            Some((handle, notifier, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            RemoteServiceRequest::DiscoverCharacteristics { .. } => "discover_characteristics",
            RemoteServiceRequest::ReadByType { .. } => "read_by_type",
            RemoteServiceRequest::ReadCharacteristic { .. } => "read_characteristic",
            RemoteServiceRequest::WriteCharacteristic { .. } => "write_characteristic",
            RemoteServiceRequest::ReadDescriptor { .. } => "read_descriptor",
            RemoteServiceRequest::WriteDescriptor { .. } => "write_descriptor",
            RemoteServiceRequest::RegisterCharacteristicNotifier { .. } => {
                "register_characteristic_notifier"
            }
        }
    }
}

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

#[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 characteristics: &[Characteristic]) -> Result<(), fidl::Error> {
        let _result = self.send_raw(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 characteristics: &[Characteristic],
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(characteristics);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut characteristics: &[Characteristic]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<RemoteServiceDiscoverCharacteristicsResponse>(
            (characteristics,),
            self.tx_id,
            0x6cd730f12e402543,
            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,
                0x739bb1e313162bbc,
                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 result: Result<&ReadValue, 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<&ReadValue, Error>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<&ReadValue, Error>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            RemoteServiceReadCharacteristicResponse,
            Error,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x4d41757ed69a96cb,
            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 result: Result<(), Error>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

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

    fn send_raw(&self, mut result: Result<(), Error>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>>(
                result,
                self.tx_id,
                0x7fc7511adecde8c,
                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 result: Result<&ReadValue, 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<&ReadValue, Error>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<&ReadValue, Error>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            RemoteServiceReadDescriptorResponse,
            Error,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x7ed7ce00457dcec1,
            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 result: Result<(), Error>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

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

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

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct RemoteServiceRegisterCharacteristicNotifierResponder {
    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 RemoteServiceRegisterCharacteristicNotifierResponder {
    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 RemoteServiceRegisterCharacteristicNotifierResponder {
    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 RemoteServiceRegisterCharacteristicNotifierResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), Error>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

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

    fn send_raw(&self, mut result: Result<(), Error>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>>(
                result,
                self.tx_id,
                0x35007a85245f5cc6,
                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.gatt2.Server";
}
impl fidl::endpoints::DiscoverableProtocolMarker for Server_Marker {}
pub type ServerPublishServiceResult = Result<(), PublishServiceError>;

pub trait Server_ProxyInterface: Send + Sync {
    type PublishServiceResponseFut: std::future::Future<Output = Result<ServerPublishServiceResult, fidl::Error>>
        + Send;
    fn r#publish_service(
        &self,
        info: &ServiceInfo,
        service: fidl::endpoints::ClientEnd<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 {
        let protocol_name = <Server_Marker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

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

    /// Publishes the given `service` so that it is available to all remote peers. Upon publication,
    /// the service is defined to have INITIAL_VALUE_CHANGED_CREDITS credits available for sending
    /// indications/notifications.
    ///
    /// The caller must assign distinct handles to the characteristics and descriptors listed in
    /// `info`. These identifiers will be used in requests sent to `service`.
    ///
    /// + request `info` Defines the structure of the GATT service. Includes characteristics and
    ///   descriptors that will be made available to peers, as well as the service handle, which is
    ///   required to be unique across all services published to this Server.
    /// + request `service` Provides the implementation of the service per the documented behavior
    ///   of a `LocalService`.
    /// - response An empty response indicates the service was successfully published.
    /// * error See `gatt2.PublishServiceError` for possible failure modes.
    pub fn r#publish_service(
        &self,
        mut info: &ServiceInfo,
        mut service: fidl::endpoints::ClientEnd<LocalServiceMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ServerPublishServiceResult, fidl::Error> {
        let _response =
            self.client.send_query::<ServerPublishServiceRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                PublishServiceError,
            >>(
                (info, service),
                0x3110442f2077bfe2,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }
}

#[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.gatt2/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. Upon publication,
    /// the service is defined to have INITIAL_VALUE_CHANGED_CREDITS credits available for sending
    /// indications/notifications.
    ///
    /// The caller must assign distinct handles to the characteristics and descriptors listed in
    /// `info`. These identifiers will be used in requests sent to `service`.
    ///
    /// + request `info` Defines the structure of the GATT service. Includes characteristics and
    ///   descriptors that will be made available to peers, as well as the service handle, which is
    ///   required to be unique across all services published to this Server.
    /// + request `service` Provides the implementation of the service per the documented behavior
    ///   of a `LocalService`.
    /// - response An empty response indicates the service was successfully published.
    /// * error See `gatt2.PublishServiceError` for possible failure modes.
    pub fn r#publish_service(
        &self,
        mut info: &ServiceInfo,
        mut service: fidl::endpoints::ClientEnd<LocalServiceMarker>,
    ) -> fidl::client::QueryResponseFut<
        ServerPublishServiceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        Server_ProxyInterface::r#publish_service(self, info, service)
    }
}

impl Server_ProxyInterface for Server_Proxy {
    type PublishServiceResponseFut = fidl::client::QueryResponseFut<
        ServerPublishServiceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#publish_service(
        &self,
        mut info: &ServiceInfo,
        mut service: fidl::endpoints::ClientEnd<LocalServiceMarker>,
    ) -> Self::PublishServiceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ServerPublishServiceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, PublishServiceError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3110442f2077bfe2,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<ServerPublishServiceRequest, ServerPublishServiceResult>(
                (info, service),
                0x3110442f2077bfe2,
                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.gatt2/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 {
                    0x3110442f2077bfe2 => {
                        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,
                            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. Upon publication,
    /// the service is defined to have INITIAL_VALUE_CHANGED_CREDITS credits available for sending
    /// indications/notifications.
    ///
    /// The caller must assign distinct handles to the characteristics and descriptors listed in
    /// `info`. These identifiers will be used in requests sent to `service`.
    ///
    /// + request `info` Defines the structure of the GATT service. Includes characteristics and
    ///   descriptors that will be made available to peers, as well as the service handle, which is
    ///   required to be unique across all services published to this Server.
    /// + request `service` Provides the implementation of the service per the documented behavior
    ///   of a `LocalService`.
    /// - response An empty response indicates the service was successfully published.
    /// * error See `gatt2.PublishServiceError` for possible failure modes.
    PublishService {
        info: ServiceInfo,
        service: fidl::endpoints::ClientEnd<LocalServiceMarker>,
        responder: Server_PublishServiceResponder,
    },
}

impl Server_Request {
    #[allow(irrefutable_let_patterns)]
    pub fn into_publish_service(
        self,
    ) -> Option<(
        ServiceInfo,
        fidl::endpoints::ClientEnd<LocalServiceMarker>,
        Server_PublishServiceResponder,
    )> {
        if let Server_Request::PublishService { info, service, responder } = self {
            Some((info, 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 result: Result<(), PublishServiceError>) -> 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<(), PublishServiceError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), PublishServiceError>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            PublishServiceError,
        >>(
            result,
            self.tx_id,
            0x3110442f2077bfe2,
            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(
                (
                    <ServiceHandle as fidl::encoding::ValueTypeMarker>::borrow(&self.handle),
                    <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<ServiceHandle, 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 {
                handle: fidl::new_empty!(
                    ServiceHandle,
                    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!(
                ServiceHandle,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.handle,
                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 LocalServiceOnIndicateValueRequest {
        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 LocalServiceOnIndicateValueRequest {
        type Owned = Self;

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

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

    unsafe impl
        fidl::encoding::Encode<
            LocalServiceOnIndicateValueRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut LocalServiceOnIndicateValueRequest
    {
        #[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::<LocalServiceOnIndicateValueRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                LocalServiceOnIndicateValueRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <ValueChangedParameters as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.update,
                    ),
                    <fidl::encoding::HandleType<
                        fidl::EventPair,
                        { fidl::ObjectType::EVENTPAIR.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.confirmation,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                ValueChangedParameters,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::EventPair,
                    { fidl::ObjectType::EVENTPAIR.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            LocalServiceOnIndicateValueRequest,
            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::<LocalServiceOnIndicateValueRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for LocalServiceOnIndicateValueRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                update: fidl::new_empty!(
                    ValueChangedParameters,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                confirmation: fidl::new_empty!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, 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(16) };
            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 + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                ValueChangedParameters,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.update,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.confirmation, decoder, offset + 16, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for RemoteServiceRegisterCharacteristicNotifierRequest {
        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 RemoteServiceRegisterCharacteristicNotifierRequest {
        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<
            RemoteServiceRegisterCharacteristicNotifierRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut RemoteServiceRegisterCharacteristicNotifierRequest
    {
        #[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::<RemoteServiceRegisterCharacteristicNotifierRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                RemoteServiceRegisterCharacteristicNotifierRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <Handle as fidl::encoding::ValueTypeMarker>::borrow(&self.handle),
                    <fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<CharacteristicNotifierMarker>,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.notifier
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<Handle, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<CharacteristicNotifierMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            RemoteServiceRegisterCharacteristicNotifierRequest,
            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::<RemoteServiceRegisterCharacteristicNotifierRequest>(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 RemoteServiceRegisterCharacteristicNotifierRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                handle: fidl::new_empty!(Handle, fidl::encoding::DefaultFuchsiaResourceDialect),
                notifier: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<CharacteristicNotifierMarker>,
                    >,
                    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!(
                Handle,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.handle,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<CharacteristicNotifierMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.notifier,
                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 {
            24
        }
    }

    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<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<LocalServiceMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            ServerPublishServiceRequest,
            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::<ServerPublishServiceRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            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),
                service: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<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.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
            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 + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                ServiceInfo,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.info,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<LocalServiceMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.service,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }
}