fidl_fuchsia_wlan_policy/

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct AccessPointListenerGetListenerRequest {
    pub updates: fidl::endpoints::ClientEnd<AccessPointStateUpdatesMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct AccessPointProviderGetControllerRequest {
    pub requests: fidl::endpoints::ServerEnd<AccessPointControllerMarker>,
    pub updates: fidl::endpoints::ClientEnd<AccessPointStateUpdatesMarker>,
}

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

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

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

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

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ClientListenerGetListenerRequest {
    pub updates: fidl::endpoints::ClientEnd<ClientStateUpdatesMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ClientProviderGetControllerRequest {
    pub requests: fidl::endpoints::ServerEnd<ClientControllerMarker>,
    pub updates: fidl::endpoints::ClientEnd<ClientStateUpdatesMarker>,
}

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

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

impl fidl::endpoints::ProtocolMarker for AccessPointControllerMarker {
    type Proxy = AccessPointControllerProxy;
    type RequestStream = AccessPointControllerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = AccessPointControllerSynchronousProxy;

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

pub trait AccessPointControllerProxyInterface: Send + Sync {
    type StartAccessPointResponseFut: std::future::Future<Output = Result<RequestStatus, fidl::Error>>
        + Send;
    fn r#start_access_point(
        &self,
        config: &NetworkConfig,
        mode: ConnectivityMode,
        band: OperatingBand,
    ) -> Self::StartAccessPointResponseFut;
    type StopAccessPointResponseFut: std::future::Future<Output = Result<RequestStatus, fidl::Error>>
        + Send;
    fn r#stop_access_point(&self, config: &NetworkConfig) -> Self::StopAccessPointResponseFut;
    fn r#stop_all_access_points(&self) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct AccessPointControllerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for AccessPointControllerSynchronousProxy {
    type Proxy = AccessPointControllerProxy;
    type Protocol = AccessPointControllerMarker;

    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 AccessPointControllerSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <AccessPointControllerMarker 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<AccessPointControllerEvent, fidl::Error> {
        AccessPointControllerEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Enables wlan to initiate AccessPoint operation using the provided network
    /// configuration, connectivity mode and band.
    pub fn r#start_access_point(
        &self,
        mut config: &NetworkConfig,
        mut mode: ConnectivityMode,
        mut band: OperatingBand,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RequestStatus, fidl::Error> {
        let _response = self.client.send_query::<
            AccessPointControllerStartAccessPointRequest,
            AccessPointControllerStartAccessPointResponse,
        >(
            (config, mode, band,),
            0x76bcb0fcf04571e7,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.status)
    }

    /// Deactivate AccessPoint operation for a specified network configuration.
    pub fn r#stop_access_point(
        &self,
        mut config: &NetworkConfig,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RequestStatus, fidl::Error> {
        let _response = self.client.send_query::<
            AccessPointControllerStopAccessPointRequest,
            AccessPointControllerStopAccessPointResponse,
        >(
            (config,),
            0xb3af7e469672bad,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.status)
    }

    /// Deactivates all AccessPoints currently operating on the device.
    pub fn r#stop_all_access_points(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x28b34d49d327cc0d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::Proxy for AccessPointControllerProxy {
    type Protocol = AccessPointControllerMarker;

    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 AccessPointControllerProxy {
    /// Create a new Proxy for fuchsia.wlan.policy/AccessPointController.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <AccessPointControllerMarker 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) -> AccessPointControllerEventStream {
        AccessPointControllerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Enables wlan to initiate AccessPoint operation using the provided network
    /// configuration, connectivity mode and band.
    pub fn r#start_access_point(
        &self,
        mut config: &NetworkConfig,
        mut mode: ConnectivityMode,
        mut band: OperatingBand,
    ) -> fidl::client::QueryResponseFut<RequestStatus, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        AccessPointControllerProxyInterface::r#start_access_point(self, config, mode, band)
    }

    /// Deactivate AccessPoint operation for a specified network configuration.
    pub fn r#stop_access_point(
        &self,
        mut config: &NetworkConfig,
    ) -> fidl::client::QueryResponseFut<RequestStatus, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        AccessPointControllerProxyInterface::r#stop_access_point(self, config)
    }

    /// Deactivates all AccessPoints currently operating on the device.
    pub fn r#stop_all_access_points(&self) -> Result<(), fidl::Error> {
        AccessPointControllerProxyInterface::r#stop_all_access_points(self)
    }
}

impl AccessPointControllerProxyInterface for AccessPointControllerProxy {
    type StartAccessPointResponseFut = fidl::client::QueryResponseFut<
        RequestStatus,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#start_access_point(
        &self,
        mut config: &NetworkConfig,
        mut mode: ConnectivityMode,
        mut band: OperatingBand,
    ) -> Self::StartAccessPointResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RequestStatus, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                AccessPointControllerStartAccessPointResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x76bcb0fcf04571e7,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client
            .send_query_and_decode::<AccessPointControllerStartAccessPointRequest, RequestStatus>(
                (config, mode, band),
                0x76bcb0fcf04571e7,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type StopAccessPointResponseFut = fidl::client::QueryResponseFut<
        RequestStatus,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#stop_access_point(&self, mut config: &NetworkConfig) -> Self::StopAccessPointResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RequestStatus, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                AccessPointControllerStopAccessPointResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xb3af7e469672bad,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client
            .send_query_and_decode::<AccessPointControllerStopAccessPointRequest, RequestStatus>(
                (config,),
                0xb3af7e469672bad,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

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

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.wlan.policy/AccessPointController.
pub struct AccessPointControllerRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for AccessPointControllerRequestStream {
    type Protocol = AccessPointControllerMarker;
    type ControlHandle = AccessPointControllerControlHandle;

    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 {
        AccessPointControllerControlHandle { 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 AccessPointControllerRequestStream {
    type Item = Result<AccessPointControllerRequest, 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 AccessPointControllerRequestStream 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 {
                0x76bcb0fcf04571e7 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(AccessPointControllerStartAccessPointRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AccessPointControllerStartAccessPointRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = AccessPointControllerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(AccessPointControllerRequest::StartAccessPoint {config: req.config,
mode: req.mode,
band: req.band,

                        responder: AccessPointControllerStartAccessPointResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0xb3af7e469672bad => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(AccessPointControllerStopAccessPointRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AccessPointControllerStopAccessPointRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = AccessPointControllerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(AccessPointControllerRequest::StopAccessPoint {config: req.config,

                        responder: AccessPointControllerStopAccessPointResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x28b34d49d327cc0d => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = AccessPointControllerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(AccessPointControllerRequest::StopAllAccessPoints {
                        control_handle,
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <AccessPointControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// AccessPointControllers allow the caller to trigger wlan state changes.  This
/// includes whether the device will act as an access point and provide a wlan
/// network for other co-located devices.
#[derive(Debug)]
pub enum AccessPointControllerRequest {
    /// Enables wlan to initiate AccessPoint operation using the provided network
    /// configuration, connectivity mode and band.
    StartAccessPoint {
        config: NetworkConfig,
        mode: ConnectivityMode,
        band: OperatingBand,
        responder: AccessPointControllerStartAccessPointResponder,
    },
    /// Deactivate AccessPoint operation for a specified network configuration.
    StopAccessPoint {
        config: NetworkConfig,
        responder: AccessPointControllerStopAccessPointResponder,
    },
    /// Deactivates all AccessPoints currently operating on the device.
    StopAllAccessPoints { control_handle: AccessPointControllerControlHandle },
}

impl AccessPointControllerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_start_access_point(
        self,
    ) -> Option<(
        NetworkConfig,
        ConnectivityMode,
        OperatingBand,
        AccessPointControllerStartAccessPointResponder,
    )> {
        if let AccessPointControllerRequest::StartAccessPoint { config, mode, band, responder } =
            self
        {
            Some((config, mode, band, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_stop_access_point(
        self,
    ) -> Option<(NetworkConfig, AccessPointControllerStopAccessPointResponder)> {
        if let AccessPointControllerRequest::StopAccessPoint { config, responder } = self {
            Some((config, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_stop_all_access_points(self) -> Option<(AccessPointControllerControlHandle)> {
        if let AccessPointControllerRequest::StopAllAccessPoints { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            AccessPointControllerRequest::StartAccessPoint { .. } => "start_access_point",
            AccessPointControllerRequest::StopAccessPoint { .. } => "stop_access_point",
            AccessPointControllerRequest::StopAllAccessPoints { .. } => "stop_all_access_points",
        }
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for AccessPointListenerMarker {
    type Proxy = AccessPointListenerProxy;
    type RequestStream = AccessPointListenerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = AccessPointListenerSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.wlan.policy.AccessPointListener";
}
impl fidl::endpoints::DiscoverableProtocolMarker for AccessPointListenerMarker {}

pub trait AccessPointListenerProxyInterface: Send + Sync {
    fn r#get_listener(
        &self,
        updates: fidl::endpoints::ClientEnd<AccessPointStateUpdatesMarker>,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct AccessPointListenerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for AccessPointListenerSynchronousProxy {
    type Proxy = AccessPointListenerProxy;
    type Protocol = AccessPointListenerMarker;

    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 AccessPointListenerSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <AccessPointListenerMarker 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<AccessPointListenerEvent, fidl::Error> {
        AccessPointListenerEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Registration for callers to receive wlan access point (ap) mode state updates.
    pub fn r#get_listener(
        &self,
        mut updates: fidl::endpoints::ClientEnd<AccessPointStateUpdatesMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AccessPointListenerGetListenerRequest>(
            (updates,),
            0xdcb327043db0ff5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::Proxy for AccessPointListenerProxy {
    type Protocol = AccessPointListenerMarker;

    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 AccessPointListenerProxy {
    /// Create a new Proxy for fuchsia.wlan.policy/AccessPointListener.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <AccessPointListenerMarker 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) -> AccessPointListenerEventStream {
        AccessPointListenerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Registration for callers to receive wlan access point (ap) mode state updates.
    pub fn r#get_listener(
        &self,
        mut updates: fidl::endpoints::ClientEnd<AccessPointStateUpdatesMarker>,
    ) -> Result<(), fidl::Error> {
        AccessPointListenerProxyInterface::r#get_listener(self, updates)
    }
}

impl AccessPointListenerProxyInterface for AccessPointListenerProxy {
    fn r#get_listener(
        &self,
        mut updates: fidl::endpoints::ClientEnd<AccessPointStateUpdatesMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AccessPointListenerGetListenerRequest>(
            (updates,),
            0xdcb327043db0ff5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.wlan.policy/AccessPointListener.
pub struct AccessPointListenerRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for AccessPointListenerRequestStream {
    type Protocol = AccessPointListenerMarker;
    type ControlHandle = AccessPointListenerControlHandle;

    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 {
        AccessPointListenerControlHandle { 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 AccessPointListenerRequestStream {
    type Item = Result<AccessPointListenerRequest, 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 AccessPointListenerRequestStream 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 {
                0xdcb327043db0ff5 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(AccessPointListenerGetListenerRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AccessPointListenerGetListenerRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = AccessPointListenerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(AccessPointListenerRequest::GetListener {updates: req.updates,

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

/// The AccessPointListener API provides a mechanism for callers to receive state change
/// updates about wlan access point operation.
#[derive(Debug)]
pub enum AccessPointListenerRequest {
    /// Registration for callers to receive wlan access point (ap) mode state updates.
    GetListener {
        updates: fidl::endpoints::ClientEnd<AccessPointStateUpdatesMarker>,
        control_handle: AccessPointListenerControlHandle,
    },
}

impl AccessPointListenerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_listener(
        self,
    ) -> Option<(
        fidl::endpoints::ClientEnd<AccessPointStateUpdatesMarker>,
        AccessPointListenerControlHandle,
    )> {
        if let AccessPointListenerRequest::GetListener { updates, control_handle } = self {
            Some((updates, control_handle))
        } else {
            None
        }
    }

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

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

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

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

impl fidl::endpoints::ProtocolMarker for AccessPointProviderMarker {
    type Proxy = AccessPointProviderProxy;
    type RequestStream = AccessPointProviderRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = AccessPointProviderSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.wlan.policy.AccessPointProvider";
}
impl fidl::endpoints::DiscoverableProtocolMarker for AccessPointProviderMarker {}

pub trait AccessPointProviderProxyInterface: Send + Sync {
    fn r#get_controller(
        &self,
        requests: fidl::endpoints::ServerEnd<AccessPointControllerMarker>,
        updates: fidl::endpoints::ClientEnd<AccessPointStateUpdatesMarker>,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct AccessPointProviderSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for AccessPointProviderSynchronousProxy {
    type Proxy = AccessPointProviderProxy;
    type Protocol = AccessPointProviderMarker;

    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 AccessPointProviderSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <AccessPointProviderMarker 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<AccessPointProviderEvent, fidl::Error> {
        AccessPointProviderEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Control channel used by a single caller to trigger wlan access point (ap) mode
    /// state changes.  The caller also provides a channel to receive wlan ap updates.
    /// Only one caller can have the control channel open at a time.  Attempts to
    /// register as a controller while there is an active control registration
    /// will result in the new caller's provided channel being closed.
    pub fn r#get_controller(
        &self,
        mut requests: fidl::endpoints::ServerEnd<AccessPointControllerMarker>,
        mut updates: fidl::endpoints::ClientEnd<AccessPointStateUpdatesMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AccessPointProviderGetControllerRequest>(
            (requests, updates),
            0x3359994735e906fc,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::Proxy for AccessPointProviderProxy {
    type Protocol = AccessPointProviderMarker;

    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 AccessPointProviderProxy {
    /// Create a new Proxy for fuchsia.wlan.policy/AccessPointProvider.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <AccessPointProviderMarker 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) -> AccessPointProviderEventStream {
        AccessPointProviderEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Control channel used by a single caller to trigger wlan access point (ap) mode
    /// state changes.  The caller also provides a channel to receive wlan ap updates.
    /// Only one caller can have the control channel open at a time.  Attempts to
    /// register as a controller while there is an active control registration
    /// will result in the new caller's provided channel being closed.
    pub fn r#get_controller(
        &self,
        mut requests: fidl::endpoints::ServerEnd<AccessPointControllerMarker>,
        mut updates: fidl::endpoints::ClientEnd<AccessPointStateUpdatesMarker>,
    ) -> Result<(), fidl::Error> {
        AccessPointProviderProxyInterface::r#get_controller(self, requests, updates)
    }
}

impl AccessPointProviderProxyInterface for AccessPointProviderProxy {
    fn r#get_controller(
        &self,
        mut requests: fidl::endpoints::ServerEnd<AccessPointControllerMarker>,
        mut updates: fidl::endpoints::ClientEnd<AccessPointStateUpdatesMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<AccessPointProviderGetControllerRequest>(
            (requests, updates),
            0x3359994735e906fc,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.wlan.policy/AccessPointProvider.
pub struct AccessPointProviderRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for AccessPointProviderRequestStream {
    type Protocol = AccessPointProviderMarker;
    type ControlHandle = AccessPointProviderControlHandle;

    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 {
        AccessPointProviderControlHandle { 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 AccessPointProviderRequestStream {
    type Item = Result<AccessPointProviderRequest, 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 AccessPointProviderRequestStream 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 {
                0x3359994735e906fc => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(AccessPointProviderGetControllerRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AccessPointProviderGetControllerRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = AccessPointProviderControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(AccessPointProviderRequest::GetController {requests: req.requests,
updates: req.updates,

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

/// The AccessPointProvider API provides a mechanism for access point
/// control and is intended to be called by applications or entities representing
/// the user (ex, Settings). This API is not intended to be called by other
/// applications to change wlan state without explicit user control.
///
/// The second aim of this API design is to eliminate the "last-caller wins"
/// paradigm by limiting the number of controlling applications.  A single caller
/// at a time is permitted to make API calls that impact wlan state.
#[derive(Debug)]
pub enum AccessPointProviderRequest {
    /// Control channel used by a single caller to trigger wlan access point (ap) mode
    /// state changes.  The caller also provides a channel to receive wlan ap updates.
    /// Only one caller can have the control channel open at a time.  Attempts to
    /// register as a controller while there is an active control registration
    /// will result in the new caller's provided channel being closed.
    GetController {
        requests: fidl::endpoints::ServerEnd<AccessPointControllerMarker>,
        updates: fidl::endpoints::ClientEnd<AccessPointStateUpdatesMarker>,
        control_handle: AccessPointProviderControlHandle,
    },
}

impl AccessPointProviderRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_controller(
        self,
    ) -> Option<(
        fidl::endpoints::ServerEnd<AccessPointControllerMarker>,
        fidl::endpoints::ClientEnd<AccessPointStateUpdatesMarker>,
        AccessPointProviderControlHandle,
    )> {
        if let AccessPointProviderRequest::GetController { requests, updates, control_handle } =
            self
        {
            Some((requests, updates, control_handle))
        } else {
            None
        }
    }

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

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

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

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

impl fidl::endpoints::ProtocolMarker for AccessPointStateUpdatesMarker {
    type Proxy = AccessPointStateUpdatesProxy;
    type RequestStream = AccessPointStateUpdatesRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = AccessPointStateUpdatesSynchronousProxy;

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

pub trait AccessPointStateUpdatesProxyInterface: Send + Sync {
    type OnAccessPointStateUpdateResponseFut: std::future::Future<Output = Result<(), fidl::Error>>
        + Send;
    fn r#on_access_point_state_update(
        &self,
        access_points: &[AccessPointState],
    ) -> Self::OnAccessPointStateUpdateResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct AccessPointStateUpdatesSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for AccessPointStateUpdatesSynchronousProxy {
    type Proxy = AccessPointStateUpdatesProxy;
    type Protocol = AccessPointStateUpdatesMarker;

    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 AccessPointStateUpdatesSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <AccessPointStateUpdatesMarker 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<AccessPointStateUpdatesEvent, fidl::Error> {
        AccessPointStateUpdatesEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Updates registered listeners with the current summary of wlan access point
    /// operating states.  This will be called when there are changes with active
    /// access point networks - both the number of access points and their
    /// individual activity.  Registered listeners are responsible for deciding
    /// what information has changed (this is dependent on when they last
    /// acknowledged the update).
    pub fn r#on_access_point_state_update(
        &self,
        mut access_points: &[AccessPointState],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            AccessPointStateUpdatesOnAccessPointStateUpdateRequest,
            fidl::encoding::EmptyPayload,
        >(
            (access_points,),
            0x116bf900a0216f4c,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }
}

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

impl fidl::endpoints::Proxy for AccessPointStateUpdatesProxy {
    type Protocol = AccessPointStateUpdatesMarker;

    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 AccessPointStateUpdatesProxy {
    /// Create a new Proxy for fuchsia.wlan.policy/AccessPointStateUpdates.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <AccessPointStateUpdatesMarker 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) -> AccessPointStateUpdatesEventStream {
        AccessPointStateUpdatesEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Updates registered listeners with the current summary of wlan access point
    /// operating states.  This will be called when there are changes with active
    /// access point networks - both the number of access points and their
    /// individual activity.  Registered listeners are responsible for deciding
    /// what information has changed (this is dependent on when they last
    /// acknowledged the update).
    pub fn r#on_access_point_state_update(
        &self,
        mut access_points: &[AccessPointState],
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        AccessPointStateUpdatesProxyInterface::r#on_access_point_state_update(self, access_points)
    }
}

impl AccessPointStateUpdatesProxyInterface for AccessPointStateUpdatesProxy {
    type OnAccessPointStateUpdateResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#on_access_point_state_update(
        &self,
        mut access_points: &[AccessPointState],
    ) -> Self::OnAccessPointStateUpdateResponseFut {
        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,
                0x116bf900a0216f4c,
            >(_buf?)?;
            Ok(_response)
        }
        self.client
            .send_query_and_decode::<AccessPointStateUpdatesOnAccessPointStateUpdateRequest, ()>(
                (access_points,),
                0x116bf900a0216f4c,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.wlan.policy/AccessPointStateUpdates.
pub struct AccessPointStateUpdatesRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for AccessPointStateUpdatesRequestStream {
    type Protocol = AccessPointStateUpdatesMarker;
    type ControlHandle = AccessPointStateUpdatesControlHandle;

    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 {
        AccessPointStateUpdatesControlHandle { 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 AccessPointStateUpdatesRequestStream {
    type Item = Result<AccessPointStateUpdatesRequest, 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 AccessPointStateUpdatesRequestStream 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 {
                0x116bf900a0216f4c => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(AccessPointStateUpdatesOnAccessPointStateUpdateRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AccessPointStateUpdatesOnAccessPointStateUpdateRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = AccessPointStateUpdatesControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(AccessPointStateUpdatesRequest::OnAccessPointStateUpdate {access_points: req.access_points,

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

/// AccessPoint operation status changes along with associated connection status.
#[derive(Debug)]
pub enum AccessPointStateUpdatesRequest {
    /// Updates registered listeners with the current summary of wlan access point
    /// operating states.  This will be called when there are changes with active
    /// access point networks - both the number of access points and their
    /// individual activity.  Registered listeners are responsible for deciding
    /// what information has changed (this is dependent on when they last
    /// acknowledged the update).
    OnAccessPointStateUpdate {
        access_points: Vec<AccessPointState>,
        responder: AccessPointStateUpdatesOnAccessPointStateUpdateResponder,
    },
}

impl AccessPointStateUpdatesRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_access_point_state_update(
        self,
    ) -> Option<(Vec<AccessPointState>, AccessPointStateUpdatesOnAccessPointStateUpdateResponder)>
    {
        if let AccessPointStateUpdatesRequest::OnAccessPointStateUpdate {
            access_points,
            responder,
        } = self
        {
            Some((access_points, responder))
        } else {
            None
        }
    }

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

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

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

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

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

    fn control_handle(&self) -> &AccessPointStateUpdatesControlHandle {
        &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 AccessPointStateUpdatesOnAccessPointStateUpdateResponder {
    /// 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,
            0x116bf900a0216f4c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for ClientControllerMarker {
    type Proxy = ClientControllerProxy;
    type RequestStream = ClientControllerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ClientControllerSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) ClientController";
}
pub type ClientControllerSaveNetworkResult = Result<(), NetworkConfigChangeError>;
pub type ClientControllerRemoveNetworkResult = Result<(), NetworkConfigChangeError>;

pub trait ClientControllerProxyInterface: Send + Sync {
    type StartClientConnectionsResponseFut: std::future::Future<Output = Result<RequestStatus, fidl::Error>>
        + Send;
    fn r#start_client_connections(&self) -> Self::StartClientConnectionsResponseFut;
    type StopClientConnectionsResponseFut: std::future::Future<Output = Result<RequestStatus, fidl::Error>>
        + Send;
    fn r#stop_client_connections(&self) -> Self::StopClientConnectionsResponseFut;
    fn r#scan_for_networks(
        &self,
        iterator: fidl::endpoints::ServerEnd<ScanResultIteratorMarker>,
    ) -> Result<(), fidl::Error>;
    type SaveNetworkResponseFut: std::future::Future<Output = Result<ClientControllerSaveNetworkResult, fidl::Error>>
        + Send;
    fn r#save_network(&self, config: &NetworkConfig) -> Self::SaveNetworkResponseFut;
    type RemoveNetworkResponseFut: std::future::Future<Output = Result<ClientControllerRemoveNetworkResult, fidl::Error>>
        + Send;
    fn r#remove_network(&self, config: &NetworkConfig) -> Self::RemoveNetworkResponseFut;
    fn r#get_saved_networks(
        &self,
        iterator: fidl::endpoints::ServerEnd<NetworkConfigIteratorMarker>,
    ) -> Result<(), fidl::Error>;
    type ConnectResponseFut: std::future::Future<Output = Result<RequestStatus, fidl::Error>> + Send;
    fn r#connect(&self, id: &NetworkIdentifier) -> Self::ConnectResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ClientControllerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ClientControllerSynchronousProxy {
    type Proxy = ClientControllerProxy;
    type Protocol = ClientControllerMarker;

    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 ClientControllerSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <ClientControllerMarker 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<ClientControllerEvent, fidl::Error> {
        ClientControllerEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Enables WLAN client functionality. Once enabled, automatic connections will be
    /// attempted for saved networks, and callers can initiate operations via the
    /// ScanForNetworks() and Connect() APIs.
    /// Depending on the underlying capabilities of the device, this call may impact
    /// other device operation (for example, acting as an access point).
    /// The returned status represents acknowledgement of the request.  The
    /// ClientListener protocol should be monitored to learn when client functionality
    /// has been enabled.
    pub fn r#start_client_connections(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RequestStatus, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            ClientControllerStartClientConnectionsResponse,
        >(
            (),
            0x7e128a21ebe53e30,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.status)
    }

    /// Tears down any existing connections to wlan networks and disables initiation of
    /// new connections.
    /// The returned status represents acknowledgements of the request.  The
    /// ClientListener protocol should be monitored to learn when client functionality
    /// has been disabled.
    pub fn r#stop_client_connections(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RequestStatus, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            ClientControllerStopClientConnectionsResponse,
        >(
            (),
            0x2b1d6dec002789e9,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.status)
    }

    /// Triggers a network scan.  Note, even in normal operation, some scan requests
    /// may be rejected due to timing with connection establishment or other critical
    /// connection maintenance.  If the scan is cancelled or errors, the caller is
    /// notified via a status update in the ScanResultIterator.
    /// In the current implementation, client connections must be started for a scan
    /// to be performed.
    pub fn r#scan_for_networks(
        &self,
        mut iterator: fidl::endpoints::ServerEnd<ScanResultIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<ClientControllerScanForNetworksRequest>(
            (iterator,),
            0x1a504b9c17efb993,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Saves a network and any credential information needed to connect.  Multiple
    /// entries for the same NetworkIdentifier can exist if the credentials are
    /// different.  If a caller attempts to save a NetworkConfig with the same
    /// NetworkIdentifier and same Credentials as a previously saved network
    /// the method will effectively be a no-op. Saved networks will be used to
    /// autoconnect, and are also available to use with the Connect() API.
    pub fn r#save_network(
        &self,
        mut config: &NetworkConfig,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ClientControllerSaveNetworkResult, fidl::Error> {
        let _response = self.client.send_query::<
            ClientControllerSaveNetworkRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, NetworkConfigChangeError>,
        >(
            (config,),
            0x7e0f216194795aa6,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Removes a saved network configuration, if one exists.  This method will
    /// automatically trigger a disconnection if the NetworkConfig was used to
    /// establish the connection.
    pub fn r#remove_network(
        &self,
        mut config: &NetworkConfig,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ClientControllerRemoveNetworkResult, fidl::Error> {
        let _response = self.client.send_query::<
            ClientControllerRemoveNetworkRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, NetworkConfigChangeError>,
        >(
            (config,),
            0x549a99b877062cf5,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Retrieve the currently saved networks using the provided iterator.
    pub fn r#get_saved_networks(
        &self,
        mut iterator: fidl::endpoints::ServerEnd<NetworkConfigIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<ClientControllerGetSavedNetworksRequest>(
            (iterator,),
            0x3ae5ff975b891276,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Request to attempt a connection to the specified network.  The target of the
    /// connect call must already be a saved network.  This call is not a
    /// blocking call for the duration of the connection attempt.  If the call cannot
    /// be immediately attempted, a failure status will be returned.  If the connection
    /// request will be attempted, an acknowledgment status will be returned.  Updates
    /// to the connection status are disseminated via the ClientStateUpdates protocol.
    /// If the connect attempt fails, the service will fall back to default behavior
    /// with scanning and connecting via network selection.
    pub fn r#connect(
        &self,
        mut id: &NetworkIdentifier,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RequestStatus, fidl::Error> {
        let _response = self
            .client
            .send_query::<ClientControllerConnectRequest, ClientControllerConnectResponse>(
                (id,),
                0x3e1496753cd4b68a,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.status)
    }
}

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

impl fidl::endpoints::Proxy for ClientControllerProxy {
    type Protocol = ClientControllerMarker;

    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 ClientControllerProxy {
    /// Create a new Proxy for fuchsia.wlan.policy/ClientController.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <ClientControllerMarker 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) -> ClientControllerEventStream {
        ClientControllerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Enables WLAN client functionality. Once enabled, automatic connections will be
    /// attempted for saved networks, and callers can initiate operations via the
    /// ScanForNetworks() and Connect() APIs.
    /// Depending on the underlying capabilities of the device, this call may impact
    /// other device operation (for example, acting as an access point).
    /// The returned status represents acknowledgement of the request.  The
    /// ClientListener protocol should be monitored to learn when client functionality
    /// has been enabled.
    pub fn r#start_client_connections(
        &self,
    ) -> fidl::client::QueryResponseFut<RequestStatus, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        ClientControllerProxyInterface::r#start_client_connections(self)
    }

    /// Tears down any existing connections to wlan networks and disables initiation of
    /// new connections.
    /// The returned status represents acknowledgements of the request.  The
    /// ClientListener protocol should be monitored to learn when client functionality
    /// has been disabled.
    pub fn r#stop_client_connections(
        &self,
    ) -> fidl::client::QueryResponseFut<RequestStatus, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        ClientControllerProxyInterface::r#stop_client_connections(self)
    }

    /// Triggers a network scan.  Note, even in normal operation, some scan requests
    /// may be rejected due to timing with connection establishment or other critical
    /// connection maintenance.  If the scan is cancelled or errors, the caller is
    /// notified via a status update in the ScanResultIterator.
    /// In the current implementation, client connections must be started for a scan
    /// to be performed.
    pub fn r#scan_for_networks(
        &self,
        mut iterator: fidl::endpoints::ServerEnd<ScanResultIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        ClientControllerProxyInterface::r#scan_for_networks(self, iterator)
    }

    /// Saves a network and any credential information needed to connect.  Multiple
    /// entries for the same NetworkIdentifier can exist if the credentials are
    /// different.  If a caller attempts to save a NetworkConfig with the same
    /// NetworkIdentifier and same Credentials as a previously saved network
    /// the method will effectively be a no-op. Saved networks will be used to
    /// autoconnect, and are also available to use with the Connect() API.
    pub fn r#save_network(
        &self,
        mut config: &NetworkConfig,
    ) -> fidl::client::QueryResponseFut<
        ClientControllerSaveNetworkResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ClientControllerProxyInterface::r#save_network(self, config)
    }

    /// Removes a saved network configuration, if one exists.  This method will
    /// automatically trigger a disconnection if the NetworkConfig was used to
    /// establish the connection.
    pub fn r#remove_network(
        &self,
        mut config: &NetworkConfig,
    ) -> fidl::client::QueryResponseFut<
        ClientControllerRemoveNetworkResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ClientControllerProxyInterface::r#remove_network(self, config)
    }

    /// Retrieve the currently saved networks using the provided iterator.
    pub fn r#get_saved_networks(
        &self,
        mut iterator: fidl::endpoints::ServerEnd<NetworkConfigIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        ClientControllerProxyInterface::r#get_saved_networks(self, iterator)
    }

    /// Request to attempt a connection to the specified network.  The target of the
    /// connect call must already be a saved network.  This call is not a
    /// blocking call for the duration of the connection attempt.  If the call cannot
    /// be immediately attempted, a failure status will be returned.  If the connection
    /// request will be attempted, an acknowledgment status will be returned.  Updates
    /// to the connection status are disseminated via the ClientStateUpdates protocol.
    /// If the connect attempt fails, the service will fall back to default behavior
    /// with scanning and connecting via network selection.
    pub fn r#connect(
        &self,
        mut id: &NetworkIdentifier,
    ) -> fidl::client::QueryResponseFut<RequestStatus, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        ClientControllerProxyInterface::r#connect(self, id)
    }
}

impl ClientControllerProxyInterface for ClientControllerProxy {
    type StartClientConnectionsResponseFut = fidl::client::QueryResponseFut<
        RequestStatus,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#start_client_connections(&self) -> Self::StartClientConnectionsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RequestStatus, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ClientControllerStartClientConnectionsResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7e128a21ebe53e30,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, RequestStatus>(
            (),
            0x7e128a21ebe53e30,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type StopClientConnectionsResponseFut = fidl::client::QueryResponseFut<
        RequestStatus,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#stop_client_connections(&self) -> Self::StopClientConnectionsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RequestStatus, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ClientControllerStopClientConnectionsResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2b1d6dec002789e9,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, RequestStatus>(
            (),
            0x2b1d6dec002789e9,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#scan_for_networks(
        &self,
        mut iterator: fidl::endpoints::ServerEnd<ScanResultIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<ClientControllerScanForNetworksRequest>(
            (iterator,),
            0x1a504b9c17efb993,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type SaveNetworkResponseFut = fidl::client::QueryResponseFut<
        ClientControllerSaveNetworkResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#save_network(&self, mut config: &NetworkConfig) -> Self::SaveNetworkResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ClientControllerSaveNetworkResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, NetworkConfigChangeError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7e0f216194795aa6,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            ClientControllerSaveNetworkRequest,
            ClientControllerSaveNetworkResult,
        >(
            (config,),
            0x7e0f216194795aa6,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type RemoveNetworkResponseFut = fidl::client::QueryResponseFut<
        ClientControllerRemoveNetworkResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#remove_network(&self, mut config: &NetworkConfig) -> Self::RemoveNetworkResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ClientControllerRemoveNetworkResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, NetworkConfigChangeError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x549a99b877062cf5,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            ClientControllerRemoveNetworkRequest,
            ClientControllerRemoveNetworkResult,
        >(
            (config,),
            0x549a99b877062cf5,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#get_saved_networks(
        &self,
        mut iterator: fidl::endpoints::ServerEnd<NetworkConfigIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<ClientControllerGetSavedNetworksRequest>(
            (iterator,),
            0x3ae5ff975b891276,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type ConnectResponseFut = fidl::client::QueryResponseFut<
        RequestStatus,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#connect(&self, mut id: &NetworkIdentifier) -> Self::ConnectResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RequestStatus, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ClientControllerConnectResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3e1496753cd4b68a,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<ClientControllerConnectRequest, RequestStatus>(
            (id,),
            0x3e1496753cd4b68a,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.wlan.policy/ClientController.
pub struct ClientControllerRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for ClientControllerRequestStream {
    type Protocol = ClientControllerMarker;
    type ControlHandle = ClientControllerControlHandle;

    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 {
        ClientControllerControlHandle { 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 ClientControllerRequestStream {
    type Item = Result<ClientControllerRequest, 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 ClientControllerRequestStream 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 {
                    0x7e128a21ebe53e30 => {
                        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 =
                            ClientControllerControlHandle { inner: this.inner.clone() };
                        Ok(ClientControllerRequest::StartClientConnections {
                            responder: ClientControllerStartClientConnectionsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2b1d6dec002789e9 => {
                        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 =
                            ClientControllerControlHandle { inner: this.inner.clone() };
                        Ok(ClientControllerRequest::StopClientConnections {
                            responder: ClientControllerStopClientConnectionsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1a504b9c17efb993 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            ClientControllerScanForNetworksRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ClientControllerScanForNetworksRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ClientControllerControlHandle { inner: this.inner.clone() };
                        Ok(ClientControllerRequest::ScanForNetworks {
                            iterator: req.iterator,

                            control_handle,
                        })
                    }
                    0x7e0f216194795aa6 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ClientControllerSaveNetworkRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ClientControllerSaveNetworkRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ClientControllerControlHandle { inner: this.inner.clone() };
                        Ok(ClientControllerRequest::SaveNetwork {
                            config: req.config,

                            responder: ClientControllerSaveNetworkResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x549a99b877062cf5 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ClientControllerRemoveNetworkRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ClientControllerRemoveNetworkRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ClientControllerControlHandle { inner: this.inner.clone() };
                        Ok(ClientControllerRequest::RemoveNetwork {
                            config: req.config,

                            responder: ClientControllerRemoveNetworkResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3ae5ff975b891276 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            ClientControllerGetSavedNetworksRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ClientControllerGetSavedNetworksRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ClientControllerControlHandle { inner: this.inner.clone() };
                        Ok(ClientControllerRequest::GetSavedNetworks {
                            iterator: req.iterator,

                            control_handle,
                        })
                    }
                    0x3e1496753cd4b68a => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ClientControllerConnectRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ClientControllerConnectRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ClientControllerControlHandle { inner: this.inner.clone() };
                        Ok(ClientControllerRequest::Connect {
                            id: req.id,

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

/// ClientControllers allow the caller to trigger wlan state changes.  This includes
/// whether connections will be attempted, scan triggers and saved network
/// configuration changes.
///
/// Individual calls provided by the API are triggered after registering with
/// the wlan ClientProvider via the OpenControlChannel call.
#[derive(Debug)]
pub enum ClientControllerRequest {
    /// Enables WLAN client functionality. Once enabled, automatic connections will be
    /// attempted for saved networks, and callers can initiate operations via the
    /// ScanForNetworks() and Connect() APIs.
    /// Depending on the underlying capabilities of the device, this call may impact
    /// other device operation (for example, acting as an access point).
    /// The returned status represents acknowledgement of the request.  The
    /// ClientListener protocol should be monitored to learn when client functionality
    /// has been enabled.
    StartClientConnections { responder: ClientControllerStartClientConnectionsResponder },
    /// Tears down any existing connections to wlan networks and disables initiation of
    /// new connections.
    /// The returned status represents acknowledgements of the request.  The
    /// ClientListener protocol should be monitored to learn when client functionality
    /// has been disabled.
    StopClientConnections { responder: ClientControllerStopClientConnectionsResponder },
    /// Triggers a network scan.  Note, even in normal operation, some scan requests
    /// may be rejected due to timing with connection establishment or other critical
    /// connection maintenance.  If the scan is cancelled or errors, the caller is
    /// notified via a status update in the ScanResultIterator.
    /// In the current implementation, client connections must be started for a scan
    /// to be performed.
    ScanForNetworks {
        iterator: fidl::endpoints::ServerEnd<ScanResultIteratorMarker>,
        control_handle: ClientControllerControlHandle,
    },
    /// Saves a network and any credential information needed to connect.  Multiple
    /// entries for the same NetworkIdentifier can exist if the credentials are
    /// different.  If a caller attempts to save a NetworkConfig with the same
    /// NetworkIdentifier and same Credentials as a previously saved network
    /// the method will effectively be a no-op. Saved networks will be used to
    /// autoconnect, and are also available to use with the Connect() API.
    SaveNetwork { config: NetworkConfig, responder: ClientControllerSaveNetworkResponder },
    /// Removes a saved network configuration, if one exists.  This method will
    /// automatically trigger a disconnection if the NetworkConfig was used to
    /// establish the connection.
    RemoveNetwork { config: NetworkConfig, responder: ClientControllerRemoveNetworkResponder },
    /// Retrieve the currently saved networks using the provided iterator.
    GetSavedNetworks {
        iterator: fidl::endpoints::ServerEnd<NetworkConfigIteratorMarker>,
        control_handle: ClientControllerControlHandle,
    },
    /// Request to attempt a connection to the specified network.  The target of the
    /// connect call must already be a saved network.  This call is not a
    /// blocking call for the duration of the connection attempt.  If the call cannot
    /// be immediately attempted, a failure status will be returned.  If the connection
    /// request will be attempted, an acknowledgment status will be returned.  Updates
    /// to the connection status are disseminated via the ClientStateUpdates protocol.
    /// If the connect attempt fails, the service will fall back to default behavior
    /// with scanning and connecting via network selection.
    Connect { id: NetworkIdentifier, responder: ClientControllerConnectResponder },
}

impl ClientControllerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_start_client_connections(
        self,
    ) -> Option<(ClientControllerStartClientConnectionsResponder)> {
        if let ClientControllerRequest::StartClientConnections { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_stop_client_connections(
        self,
    ) -> Option<(ClientControllerStopClientConnectionsResponder)> {
        if let ClientControllerRequest::StopClientConnections { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_scan_for_networks(
        self,
    ) -> Option<(fidl::endpoints::ServerEnd<ScanResultIteratorMarker>, ClientControllerControlHandle)>
    {
        if let ClientControllerRequest::ScanForNetworks { iterator, control_handle } = self {
            Some((iterator, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_save_network(
        self,
    ) -> Option<(NetworkConfig, ClientControllerSaveNetworkResponder)> {
        if let ClientControllerRequest::SaveNetwork { config, responder } = self {
            Some((config, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_remove_network(
        self,
    ) -> Option<(NetworkConfig, ClientControllerRemoveNetworkResponder)> {
        if let ClientControllerRequest::RemoveNetwork { config, responder } = self {
            Some((config, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_saved_networks(
        self,
    ) -> Option<(
        fidl::endpoints::ServerEnd<NetworkConfigIteratorMarker>,
        ClientControllerControlHandle,
    )> {
        if let ClientControllerRequest::GetSavedNetworks { iterator, control_handle } = self {
            Some((iterator, control_handle))
        } else {
            None
        }
    }

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

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            ClientControllerRequest::StartClientConnections { .. } => "start_client_connections",
            ClientControllerRequest::StopClientConnections { .. } => "stop_client_connections",
            ClientControllerRequest::ScanForNetworks { .. } => "scan_for_networks",
            ClientControllerRequest::SaveNetwork { .. } => "save_network",
            ClientControllerRequest::RemoveNetwork { .. } => "remove_network",
            ClientControllerRequest::GetSavedNetworks { .. } => "get_saved_networks",
            ClientControllerRequest::Connect { .. } => "connect",
        }
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for ClientListenerMarker {
    type Proxy = ClientListenerProxy;
    type RequestStream = ClientListenerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ClientListenerSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.wlan.policy.ClientListener";
}
impl fidl::endpoints::DiscoverableProtocolMarker for ClientListenerMarker {}

pub trait ClientListenerProxyInterface: Send + Sync {
    fn r#get_listener(
        &self,
        updates: fidl::endpoints::ClientEnd<ClientStateUpdatesMarker>,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ClientListenerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ClientListenerSynchronousProxy {
    type Proxy = ClientListenerProxy;
    type Protocol = ClientListenerMarker;

    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 ClientListenerSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <ClientListenerMarker 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<ClientListenerEvent, fidl::Error> {
        ClientListenerEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Registration for callers to receive wlan client mode state updates.
    pub fn r#get_listener(
        &self,
        mut updates: fidl::endpoints::ClientEnd<ClientStateUpdatesMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<ClientListenerGetListenerRequest>(
            (updates,),
            0x3fe3cd14f701dedd,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::Proxy for ClientListenerProxy {
    type Protocol = ClientListenerMarker;

    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 ClientListenerProxy {
    /// Create a new Proxy for fuchsia.wlan.policy/ClientListener.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <ClientListenerMarker 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) -> ClientListenerEventStream {
        ClientListenerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Registration for callers to receive wlan client mode state updates.
    pub fn r#get_listener(
        &self,
        mut updates: fidl::endpoints::ClientEnd<ClientStateUpdatesMarker>,
    ) -> Result<(), fidl::Error> {
        ClientListenerProxyInterface::r#get_listener(self, updates)
    }
}

impl ClientListenerProxyInterface for ClientListenerProxy {
    fn r#get_listener(
        &self,
        mut updates: fidl::endpoints::ClientEnd<ClientStateUpdatesMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<ClientListenerGetListenerRequest>(
            (updates,),
            0x3fe3cd14f701dedd,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.wlan.policy/ClientListener.
pub struct ClientListenerRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for ClientListenerRequestStream {
    type Protocol = ClientListenerMarker;
    type ControlHandle = ClientListenerControlHandle;

    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 {
        ClientListenerControlHandle { 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 ClientListenerRequestStream {
    type Item = Result<ClientListenerRequest, 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 ClientListenerRequestStream 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 {
                    0x3fe3cd14f701dedd => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            ClientListenerGetListenerRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ClientListenerGetListenerRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ClientListenerControlHandle { inner: this.inner.clone() };
                        Ok(ClientListenerRequest::GetListener {
                            updates: req.updates,

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

/// The ClientListener API provides a mechanism for callers to receive state change
/// updates about wlan operation.
#[derive(Debug)]
pub enum ClientListenerRequest {
    /// Registration for callers to receive wlan client mode state updates.
    GetListener {
        updates: fidl::endpoints::ClientEnd<ClientStateUpdatesMarker>,
        control_handle: ClientListenerControlHandle,
    },
}

impl ClientListenerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_listener(
        self,
    ) -> Option<(fidl::endpoints::ClientEnd<ClientStateUpdatesMarker>, ClientListenerControlHandle)>
    {
        if let ClientListenerRequest::GetListener { updates, control_handle } = self {
            Some((updates, control_handle))
        } else {
            None
        }
    }

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

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

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

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

impl fidl::endpoints::ProtocolMarker for ClientProviderMarker {
    type Proxy = ClientProviderProxy;
    type RequestStream = ClientProviderRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ClientProviderSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.wlan.policy.ClientProvider";
}
impl fidl::endpoints::DiscoverableProtocolMarker for ClientProviderMarker {}

pub trait ClientProviderProxyInterface: Send + Sync {
    fn r#get_controller(
        &self,
        requests: fidl::endpoints::ServerEnd<ClientControllerMarker>,
        updates: fidl::endpoints::ClientEnd<ClientStateUpdatesMarker>,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ClientProviderSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ClientProviderSynchronousProxy {
    type Proxy = ClientProviderProxy;
    type Protocol = ClientProviderMarker;

    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 ClientProviderSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <ClientProviderMarker 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<ClientProviderEvent, fidl::Error> {
        ClientProviderEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Control channel used by a single caller to trigger wlan client mode state
    /// changes.  The caller also provides a channel to receive wlan updates.
    /// Only one caller can have the control channel open at a time.  Attempts to
    /// register as a controller while there is an active control registration
    /// will result in the new caller's provided channel being closed.
    pub fn r#get_controller(
        &self,
        mut requests: fidl::endpoints::ServerEnd<ClientControllerMarker>,
        mut updates: fidl::endpoints::ClientEnd<ClientStateUpdatesMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<ClientProviderGetControllerRequest>(
            (requests, updates),
            0x7559282e8bf18fd6,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::Proxy for ClientProviderProxy {
    type Protocol = ClientProviderMarker;

    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 ClientProviderProxy {
    /// Create a new Proxy for fuchsia.wlan.policy/ClientProvider.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <ClientProviderMarker 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) -> ClientProviderEventStream {
        ClientProviderEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Control channel used by a single caller to trigger wlan client mode state
    /// changes.  The caller also provides a channel to receive wlan updates.
    /// Only one caller can have the control channel open at a time.  Attempts to
    /// register as a controller while there is an active control registration
    /// will result in the new caller's provided channel being closed.
    pub fn r#get_controller(
        &self,
        mut requests: fidl::endpoints::ServerEnd<ClientControllerMarker>,
        mut updates: fidl::endpoints::ClientEnd<ClientStateUpdatesMarker>,
    ) -> Result<(), fidl::Error> {
        ClientProviderProxyInterface::r#get_controller(self, requests, updates)
    }
}

impl ClientProviderProxyInterface for ClientProviderProxy {
    fn r#get_controller(
        &self,
        mut requests: fidl::endpoints::ServerEnd<ClientControllerMarker>,
        mut updates: fidl::endpoints::ClientEnd<ClientStateUpdatesMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<ClientProviderGetControllerRequest>(
            (requests, updates),
            0x7559282e8bf18fd6,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.wlan.policy/ClientProvider.
pub struct ClientProviderRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for ClientProviderRequestStream {
    type Protocol = ClientProviderMarker;
    type ControlHandle = ClientProviderControlHandle;

    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 {
        ClientProviderControlHandle { 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 ClientProviderRequestStream {
    type Item = Result<ClientProviderRequest, 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 ClientProviderRequestStream 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 {
                    0x7559282e8bf18fd6 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            ClientProviderGetControllerRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ClientProviderGetControllerRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ClientProviderControlHandle { inner: this.inner.clone() };
                        Ok(ClientProviderRequest::GetController {
                            requests: req.requests,
                            updates: req.updates,

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

/// The ClientProvider API provides a mechanism for wlan control and is intended
/// to be called by applications or entities representing the user (ex, Settings).
/// This API is not intended to be called by other applications to change wlan
/// state without explicit user control.
///
/// The second aim of this API design is to eliminate the "last-caller wins"
/// paradigm by limiting the number of controlling applications.  A single caller
/// at a time is permitted to make API calls that impact wlan state.
#[derive(Debug)]
pub enum ClientProviderRequest {
    /// Control channel used by a single caller to trigger wlan client mode state
    /// changes.  The caller also provides a channel to receive wlan updates.
    /// Only one caller can have the control channel open at a time.  Attempts to
    /// register as a controller while there is an active control registration
    /// will result in the new caller's provided channel being closed.
    GetController {
        requests: fidl::endpoints::ServerEnd<ClientControllerMarker>,
        updates: fidl::endpoints::ClientEnd<ClientStateUpdatesMarker>,
        control_handle: ClientProviderControlHandle,
    },
}

impl ClientProviderRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_controller(
        self,
    ) -> Option<(
        fidl::endpoints::ServerEnd<ClientControllerMarker>,
        fidl::endpoints::ClientEnd<ClientStateUpdatesMarker>,
        ClientProviderControlHandle,
    )> {
        if let ClientProviderRequest::GetController { requests, updates, control_handle } = self {
            Some((requests, updates, control_handle))
        } else {
            None
        }
    }

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

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

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

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

impl fidl::endpoints::ProtocolMarker for ClientStateUpdatesMarker {
    type Proxy = ClientStateUpdatesProxy;
    type RequestStream = ClientStateUpdatesRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ClientStateUpdatesSynchronousProxy;

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

pub trait ClientStateUpdatesProxyInterface: Send + Sync {
    type OnClientStateUpdateResponseFut: std::future::Future<Output = Result<(), fidl::Error>>
        + Send;
    fn r#on_client_state_update(
        &self,
        summary: &ClientStateSummary,
    ) -> Self::OnClientStateUpdateResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ClientStateUpdatesSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ClientStateUpdatesSynchronousProxy {
    type Proxy = ClientStateUpdatesProxy;
    type Protocol = ClientStateUpdatesMarker;

    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 ClientStateUpdatesSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <ClientStateUpdatesMarker 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<ClientStateUpdatesEvent, fidl::Error> {
        ClientStateUpdatesEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Updates registered listeners with the current summary of wlan client state.
    /// This will be called when there is any change to the state and the
    /// registered listeners are responsible for deciding what information has
    /// changed (since this is dependent on when they last acknowledged the update).
    pub fn r#on_client_state_update(
        &self,
        mut summary: &ClientStateSummary,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            ClientStateUpdatesOnClientStateUpdateRequest,
            fidl::encoding::EmptyPayload,
        >(
            (summary,),
            0x2a41c1993e122b85,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }
}

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

impl fidl::endpoints::Proxy for ClientStateUpdatesProxy {
    type Protocol = ClientStateUpdatesMarker;

    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 ClientStateUpdatesProxy {
    /// Create a new Proxy for fuchsia.wlan.policy/ClientStateUpdates.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <ClientStateUpdatesMarker 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) -> ClientStateUpdatesEventStream {
        ClientStateUpdatesEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Updates registered listeners with the current summary of wlan client state.
    /// This will be called when there is any change to the state and the
    /// registered listeners are responsible for deciding what information has
    /// changed (since this is dependent on when they last acknowledged the update).
    pub fn r#on_client_state_update(
        &self,
        mut summary: &ClientStateSummary,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        ClientStateUpdatesProxyInterface::r#on_client_state_update(self, summary)
    }
}

impl ClientStateUpdatesProxyInterface for ClientStateUpdatesProxy {
    type OnClientStateUpdateResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#on_client_state_update(
        &self,
        mut summary: &ClientStateSummary,
    ) -> Self::OnClientStateUpdateResponseFut {
        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,
                0x2a41c1993e122b85,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<ClientStateUpdatesOnClientStateUpdateRequest, ()>(
            (summary,),
            0x2a41c1993e122b85,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.wlan.policy/ClientStateUpdates.
pub struct ClientStateUpdatesRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for ClientStateUpdatesRequestStream {
    type Protocol = ClientStateUpdatesMarker;
    type ControlHandle = ClientStateUpdatesControlHandle;

    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 {
        ClientStateUpdatesControlHandle { 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 ClientStateUpdatesRequestStream {
    type Item = Result<ClientStateUpdatesRequest, 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 ClientStateUpdatesRequestStream 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 {
                0x2a41c1993e122b85 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(ClientStateUpdatesOnClientStateUpdateRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ClientStateUpdatesOnClientStateUpdateRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = ClientStateUpdatesControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(ClientStateUpdatesRequest::OnClientStateUpdate {summary: req.summary,

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

/// Wlan status changes for client connections and the associated network state.
/// These updates contain information about whether or not the device will attempt
/// to connect to networks, saved network configuration change information,
/// individual connection state information by NetworkIdentifier and connection
/// attempt information.  The connection and network related calls are based on
/// NetworkIdentifier to allow multiple simultaneous connections on supporting
/// devices.
#[derive(Debug)]
pub enum ClientStateUpdatesRequest {
    /// Updates registered listeners with the current summary of wlan client state.
    /// This will be called when there is any change to the state and the
    /// registered listeners are responsible for deciding what information has
    /// changed (since this is dependent on when they last acknowledged the update).
    OnClientStateUpdate {
        summary: ClientStateSummary,
        responder: ClientStateUpdatesOnClientStateUpdateResponder,
    },
}

impl ClientStateUpdatesRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_client_state_update(
        self,
    ) -> Option<(ClientStateSummary, ClientStateUpdatesOnClientStateUpdateResponder)> {
        if let ClientStateUpdatesRequest::OnClientStateUpdate { summary, responder } = self {
            Some((summary, responder))
        } else {
            None
        }
    }

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

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

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

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

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

    fn control_handle(&self) -> &ClientStateUpdatesControlHandle {
        &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 ClientStateUpdatesOnClientStateUpdateResponder {
    /// 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,
            0x2a41c1993e122b85,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for NetworkConfigIteratorMarker {
    type Proxy = NetworkConfigIteratorProxy;
    type RequestStream = NetworkConfigIteratorRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = NetworkConfigIteratorSynchronousProxy;

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

pub trait NetworkConfigIteratorProxyInterface: Send + Sync {
    type GetNextResponseFut: std::future::Future<Output = Result<Vec<NetworkConfig>, fidl::Error>>
        + Send;
    fn r#get_next(&self) -> Self::GetNextResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct NetworkConfigIteratorSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for NetworkConfigIteratorSynchronousProxy {
    type Proxy = NetworkConfigIteratorProxy;
    type Protocol = NetworkConfigIteratorMarker;

    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 NetworkConfigIteratorSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <NetworkConfigIteratorMarker 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<NetworkConfigIteratorEvent, fidl::Error> {
        NetworkConfigIteratorEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Method allowing the next block of saved networks to be handled.
    pub fn r#get_next(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Vec<NetworkConfig>, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, NetworkConfigIteratorGetNextResponse>(
                (),
                0x61686c07483bdec0,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.configs)
    }
}

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

impl fidl::endpoints::Proxy for NetworkConfigIteratorProxy {
    type Protocol = NetworkConfigIteratorMarker;

    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 NetworkConfigIteratorProxy {
    /// Create a new Proxy for fuchsia.wlan.policy/NetworkConfigIterator.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <NetworkConfigIteratorMarker 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) -> NetworkConfigIteratorEventStream {
        NetworkConfigIteratorEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Method allowing the next block of saved networks to be handled.
    pub fn r#get_next(
        &self,
    ) -> fidl::client::QueryResponseFut<
        Vec<NetworkConfig>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        NetworkConfigIteratorProxyInterface::r#get_next(self)
    }
}

impl NetworkConfigIteratorProxyInterface for NetworkConfigIteratorProxy {
    type GetNextResponseFut = fidl::client::QueryResponseFut<
        Vec<NetworkConfig>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_next(&self) -> Self::GetNextResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<NetworkConfig>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NetworkConfigIteratorGetNextResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x61686c07483bdec0,
            >(_buf?)?;
            Ok(_response.configs)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<NetworkConfig>>(
            (),
            0x61686c07483bdec0,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.wlan.policy/NetworkConfigIterator.
pub struct NetworkConfigIteratorRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for NetworkConfigIteratorRequestStream {
    type Protocol = NetworkConfigIteratorMarker;
    type ControlHandle = NetworkConfigIteratorControlHandle;

    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 {
        NetworkConfigIteratorControlHandle { 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 NetworkConfigIteratorRequestStream {
    type Item = Result<NetworkConfigIteratorRequest, 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 NetworkConfigIteratorRequestStream 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 {
                0x61686c07483bdec0 => {
                    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 = NetworkConfigIteratorControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(NetworkConfigIteratorRequest::GetNext {
                        responder: NetworkConfigIteratorGetNextResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <NetworkConfigIteratorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// Iterator used by callers to retrieve saved network information.
#[derive(Debug)]
pub enum NetworkConfigIteratorRequest {
    /// Method allowing the next block of saved networks to be handled.
    GetNext { responder: NetworkConfigIteratorGetNextResponder },
}

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

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

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

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

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

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

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

    fn send_raw(&self, mut configs: &[NetworkConfig]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<NetworkConfigIteratorGetNextResponse>(
            (configs,),
            self.tx_id,
            0x61686c07483bdec0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for ScanResultIteratorMarker {
    type Proxy = ScanResultIteratorProxy;
    type RequestStream = ScanResultIteratorRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ScanResultIteratorSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) ScanResultIterator";
}
pub type ScanResultIteratorGetNextResult = Result<Vec<ScanResult>, ScanErrorCode>;

pub trait ScanResultIteratorProxyInterface: Send + Sync {
    type GetNextResponseFut: std::future::Future<Output = Result<ScanResultIteratorGetNextResult, fidl::Error>>
        + Send;
    fn r#get_next(&self) -> Self::GetNextResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ScanResultIteratorSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ScanResultIteratorSynchronousProxy {
    type Proxy = ScanResultIteratorProxy;
    type Protocol = ScanResultIteratorMarker;

    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 ScanResultIteratorSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <ScanResultIteratorMarker 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<ScanResultIteratorEvent, fidl::Error> {
        ScanResultIteratorEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Allows caller to request the next set of scan results.
    /// After all scan results have been sent, the next call to GetNext will return
    /// an empty vector and the channel will be closed.
    /// If an error is encountered during the scan, the error will be returned and
    /// the channel will be closed. No scan results will be provided.
    pub fn r#get_next(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ScanResultIteratorGetNextResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                ScanResultIteratorGetNextResponse,
                ScanErrorCode,
            >>(
                (),
                0x29cb4912ab2dc51f,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.scan_results))
    }
}

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

impl fidl::endpoints::Proxy for ScanResultIteratorProxy {
    type Protocol = ScanResultIteratorMarker;

    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 ScanResultIteratorProxy {
    /// Create a new Proxy for fuchsia.wlan.policy/ScanResultIterator.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <ScanResultIteratorMarker 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) -> ScanResultIteratorEventStream {
        ScanResultIteratorEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Allows caller to request the next set of scan results.
    /// After all scan results have been sent, the next call to GetNext will return
    /// an empty vector and the channel will be closed.
    /// If an error is encountered during the scan, the error will be returned and
    /// the channel will be closed. No scan results will be provided.
    pub fn r#get_next(
        &self,
    ) -> fidl::client::QueryResponseFut<
        ScanResultIteratorGetNextResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ScanResultIteratorProxyInterface::r#get_next(self)
    }
}

impl ScanResultIteratorProxyInterface for ScanResultIteratorProxy {
    type GetNextResponseFut = fidl::client::QueryResponseFut<
        ScanResultIteratorGetNextResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_next(&self) -> Self::GetNextResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ScanResultIteratorGetNextResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<ScanResultIteratorGetNextResponse, ScanErrorCode>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x29cb4912ab2dc51f,
            >(_buf?)?;
            Ok(_response.map(|x| x.scan_results))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, ScanResultIteratorGetNextResult>(
                (),
                0x29cb4912ab2dc51f,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.wlan.policy/ScanResultIterator.
pub struct ScanResultIteratorRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for ScanResultIteratorRequestStream {
    type Protocol = ScanResultIteratorMarker;
    type ControlHandle = ScanResultIteratorControlHandle;

    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 {
        ScanResultIteratorControlHandle { 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 ScanResultIteratorRequestStream {
    type Item = Result<ScanResultIteratorRequest, 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 ScanResultIteratorRequestStream 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 {
                0x29cb4912ab2dc51f => {
                    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 = ScanResultIteratorControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(ScanResultIteratorRequest::GetNext {
                        responder: ScanResultIteratorGetNextResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <ScanResultIteratorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// Iterator used to send back scan results to the caller.  The corresponding channel
/// will be closed after the scan is complete and results are returned or fails due
/// to an error.
#[derive(Debug)]
pub enum ScanResultIteratorRequest {
    /// Allows caller to request the next set of scan results.
    /// After all scan results have been sent, the next call to GetNext will return
    /// an empty vector and the channel will be closed.
    /// If an error is encountered during the scan, the error will be returned and
    /// the channel will be closed. No scan results will be provided.
    GetNext { responder: ScanResultIteratorGetNextResponder },
}

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

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

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

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

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

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

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

    fn send_raw(
        &self,
        mut result: Result<&[ScanResult], ScanErrorCode>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            ScanResultIteratorGetNextResponse,
            ScanErrorCode,
        >>(
            result.map(|scan_results| (scan_results,)),
            self.tx_id,
            0x29cb4912ab2dc51f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

mod internal {
    use super::*;

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for AccessPointListenerGetListenerRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                updates: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<AccessPointStateUpdatesMarker>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            AccessPointProviderGetControllerRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut AccessPointProviderGetControllerRequest
    {
        #[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::<AccessPointProviderGetControllerRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                AccessPointProviderGetControllerRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<AccessPointControllerMarker>,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.requests
                    ),
                    <fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<AccessPointStateUpdatesMarker>,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.updates
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<AccessPointControllerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<AccessPointStateUpdatesMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            AccessPointProviderGetControllerRequest,
            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::<AccessPointProviderGetControllerRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for AccessPointProviderGetControllerRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                requests: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<AccessPointControllerMarker>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                updates: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<AccessPointStateUpdatesMarker>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ClientListenerGetListenerRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                updates: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ClientStateUpdatesMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            ClientProviderGetControllerRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ClientProviderGetControllerRequest
    {
        #[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::<ClientProviderGetControllerRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ClientProviderGetControllerRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ClientControllerMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.requests),
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ClientStateUpdatesMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.updates),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ClientControllerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ClientStateUpdatesMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            ClientProviderGetControllerRequest,
            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::<ClientProviderGetControllerRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ClientProviderGetControllerRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                requests: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ClientControllerMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                updates: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ClientStateUpdatesMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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