fdomain_fuchsia_net_routes_admin/

fdomain_fuchsia_net_routes_admin.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 fdomain_client::fidl::{ControlHandle as _, FDomainFlexibleIntoResult as _, Responder as _};
use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
pub use fidl_fuchsia_net_routes_admin_common::*;
use futures::future::{self, MaybeDone, TryFutureExt};
use zx_status;

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct BaseRouteTableGetAuthorizationForRouteTableResponse {
    pub credential: GrantForRouteTableAuthorization,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect>
    for BaseRouteTableGetAuthorizationForRouteTableResponse
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct GrantForRouteTableAuthorization {
    /// The ID of the table this credential is authenticating.
    pub table_id: u32,
    /// The `EVENT` providing authentication over this route table.
    pub token: fdomain_client::Event,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect>
    for GrantForRouteTableAuthorization
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ProofOfRouteTableAuthorization {
    pub table: u32,
    pub token: fdomain_client::Event,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect>
    for ProofOfRouteTableAuthorization
{
}

#[derive(Debug, PartialEq)]
pub struct RouteSetV4AddRouteRequest {
    pub route: fdomain_fuchsia_net_routes::RouteV4,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect> for RouteSetV4AddRouteRequest {}

#[derive(Debug, PartialEq)]
pub struct RouteSetV4AuthenticateForInterfaceRequest {
    pub credential: fdomain_fuchsia_net_resources::ProofOfInterfaceAuthorization,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect>
    for RouteSetV4AuthenticateForInterfaceRequest
{
}

#[derive(Debug, PartialEq)]
pub struct RouteSetV4RemoveRouteRequest {
    pub route: fdomain_fuchsia_net_routes::RouteV4,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect>
    for RouteSetV4RemoveRouteRequest
{
}

#[derive(Debug, PartialEq)]
pub struct RouteSetV6AddRouteRequest {
    pub route: fdomain_fuchsia_net_routes::RouteV6,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect> for RouteSetV6AddRouteRequest {}

#[derive(Debug, PartialEq)]
pub struct RouteSetV6AuthenticateForInterfaceRequest {
    pub credential: fdomain_fuchsia_net_resources::ProofOfInterfaceAuthorization,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect>
    for RouteSetV6AuthenticateForInterfaceRequest
{
}

#[derive(Debug, PartialEq)]
pub struct RouteSetV6RemoveRouteRequest {
    pub route: fdomain_fuchsia_net_routes::RouteV6,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect>
    for RouteSetV6RemoveRouteRequest
{
}

#[derive(Debug, PartialEq)]
pub struct RouteTableProviderV4GetInterfaceLocalTableRequest {
    pub credential: fdomain_fuchsia_net_resources::ProofOfInterfaceAuthorization,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect>
    for RouteTableProviderV4GetInterfaceLocalTableRequest
{
}

#[derive(Debug, PartialEq)]
pub struct RouteTableProviderV4NewRouteTableRequest {
    pub provider: fdomain_client::fidl::ServerEnd<RouteTableV4Marker>,
    pub options: RouteTableOptionsV4,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect>
    for RouteTableProviderV4NewRouteTableRequest
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RouteTableProviderV4GetInterfaceLocalTableResponse {
    pub route_table: fdomain_client::fidl::ClientEnd<RouteTableV4Marker>,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect>
    for RouteTableProviderV4GetInterfaceLocalTableResponse
{
}

#[derive(Debug, PartialEq)]
pub struct RouteTableProviderV6GetInterfaceLocalTableRequest {
    pub credential: fdomain_fuchsia_net_resources::ProofOfInterfaceAuthorization,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect>
    for RouteTableProviderV6GetInterfaceLocalTableRequest
{
}

#[derive(Debug, PartialEq)]
pub struct RouteTableProviderV6NewRouteTableRequest {
    pub provider: fdomain_client::fidl::ServerEnd<RouteTableV6Marker>,
    pub options: RouteTableOptionsV6,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect>
    for RouteTableProviderV6NewRouteTableRequest
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RouteTableProviderV6GetInterfaceLocalTableResponse {
    pub route_table: fdomain_client::fidl::ClientEnd<RouteTableV6Marker>,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect>
    for RouteTableProviderV6GetInterfaceLocalTableResponse
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RouteTableV4NewRouteSetRequest {
    pub route_set: fdomain_client::fidl::ServerEnd<RouteSetV4Marker>,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect>
    for RouteTableV4NewRouteSetRequest
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RouteTableV6NewRouteSetRequest {
    pub route_set: fdomain_client::fidl::ServerEnd<RouteSetV6Marker>,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect>
    for RouteTableV6NewRouteSetRequest
{
}

#[derive(Debug, PartialEq)]
pub struct RuleSetV4AddRuleRequest {
    pub index: u32,
    pub matcher: fdomain_fuchsia_net_routes::RuleMatcherV4,
    pub action: fdomain_fuchsia_net_routes::RuleAction,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect> for RuleSetV4AddRuleRequest {}

#[derive(Debug, PartialEq)]
pub struct RuleSetV6AddRuleRequest {
    pub index: u32,
    pub matcher: fdomain_fuchsia_net_routes::RuleMatcherV6,
    pub action: fdomain_fuchsia_net_routes::RuleAction,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect> for RuleSetV6AddRuleRequest {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RuleTableV4NewRuleSetRequest {
    pub priority: u32,
    pub rule_set: fdomain_client::fidl::ServerEnd<RuleSetV4Marker>,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect>
    for RuleTableV4NewRuleSetRequest
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RuleTableV6NewRuleSetRequest {
    pub priority: u32,
    pub rule_set: fdomain_client::fidl::ServerEnd<RuleSetV6Marker>,
}

impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect>
    for RuleTableV6NewRuleSetRequest
{
}

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

impl fdomain_client::fidl::ProtocolMarker for BaseRouteTableMarker {
    type Proxy = BaseRouteTableProxy;
    type RequestStream = BaseRouteTableRequestStream;

    const DEBUG_NAME: &'static str = "(anonymous) BaseRouteTable";
}
pub type BaseRouteTableRemoveResult = Result<(), BaseRouteTableRemoveError>;

pub trait BaseRouteTableProxyInterface: Send + Sync {
    type GetTableIdResponseFut: std::future::Future<Output = Result<u32, fidl::Error>> + Send;
    fn r#get_table_id(&self) -> Self::GetTableIdResponseFut;
    fn r#detach(&self) -> Result<(), fidl::Error>;
    type RemoveResponseFut: std::future::Future<Output = Result<BaseRouteTableRemoveResult, fidl::Error>>
        + Send;
    fn r#remove(&self) -> Self::RemoveResponseFut;
    type GetAuthorizationForRouteTableResponseFut: std::future::Future<Output = Result<GrantForRouteTableAuthorization, fidl::Error>>
        + Send;
    fn r#get_authorization_for_route_table(&self)
    -> Self::GetAuthorizationForRouteTableResponseFut;
}

#[derive(Debug, Clone)]
pub struct BaseRouteTableProxy {
    client: fidl::client::Client<fdomain_client::fidl::FDomainResourceDialect>,
}

impl fdomain_client::fidl::Proxy for BaseRouteTableProxy {
    type Protocol = BaseRouteTableMarker;

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

    fn into_channel(self) -> Result<fdomain_client::Channel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

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

impl BaseRouteTableProxy {
    /// Create a new Proxy for fuchsia.net.routes.admin/BaseRouteTable.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name =
            <BaseRouteTableMarker as fdomain_client::fidl::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) -> BaseRouteTableEventStream {
        BaseRouteTableEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Gets the table ID for this table.
    pub fn r#get_table_id(
        &self,
    ) -> fidl::client::QueryResponseFut<u32, fdomain_client::fidl::FDomainResourceDialect> {
        BaseRouteTableProxyInterface::r#get_table_id(self)
    }

    /// Detaches the lifetime of the route table from the lifetime of the
    /// client end of the channel.
    ///
    /// After this method is called, the route table will not be removed
    /// if the client end is closed. It's a no-op if called on the main table.
    pub fn r#detach(&self) -> Result<(), fidl::Error> {
        BaseRouteTableProxyInterface::r#detach(self)
    }

    /// Removes the route table explicitly.
    ///
    /// This method cannot be called on the main table or an interface-local
    /// table, an error will be returned if called. The server will close the
    /// channel after this method successfully returns.
    pub fn r#remove(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseRouteTableRemoveResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        BaseRouteTableProxyInterface::r#remove(self)
    }

    /// Gets an authentication credential for this table.
    ///
    /// The credential contains a [`zx::handle::EVENT`], whose duplicate is
    /// held by the server. This credential can be passed into
    /// `fuchsia.net.routes.admin` API calls to prove ownership of this route
    /// table. The `EVENT` is stable throughout the lifetime of the route table.
    /// Clients may duplicate this `EVENT` to make multiple API calls, or
    /// transfer the `EVENT` to other clients.
    ///
    /// - response `credential` the authorization credential for this table.
    pub fn r#get_authorization_for_route_table(
        &self,
    ) -> fidl::client::QueryResponseFut<
        GrantForRouteTableAuthorization,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        BaseRouteTableProxyInterface::r#get_authorization_for_route_table(self)
    }
}

impl BaseRouteTableProxyInterface for BaseRouteTableProxy {
    type GetTableIdResponseFut =
        fidl::client::QueryResponseFut<u32, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#get_table_id(&self) -> Self::GetTableIdResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<u32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                BaseRouteTableGetTableIdResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x7eab30c55edbfc15,
            >(_buf?)?;
            Ok(_response.table_id)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, u32>(
            (),
            0x7eab30c55edbfc15,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

    type RemoveResponseFut = fidl::client::QueryResponseFut<
        BaseRouteTableRemoveResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#remove(&self) -> Self::RemoveResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseRouteTableRemoveResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, BaseRouteTableRemoveError>,
                fdomain_client::fidl::FDomainResourceDialect,
                0xc42e58a5fc79426,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseRouteTableRemoveResult>(
                (),
                0xc42e58a5fc79426,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetAuthorizationForRouteTableResponseFut = fidl::client::QueryResponseFut<
        GrantForRouteTableAuthorization,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_authorization_for_route_table(
        &self,
    ) -> Self::GetAuthorizationForRouteTableResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<GrantForRouteTableAuthorization, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                BaseRouteTableGetAuthorizationForRouteTableResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x56a48c921ff3b6eb,
            >(_buf?)?;
            Ok(_response.credential)
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, GrantForRouteTableAuthorization>(
                (),
                0x56a48c921ff3b6eb,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }
}

pub struct BaseRouteTableEventStream {
    event_receiver: fidl::client::EventReceiver<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.net.routes.admin/BaseRouteTable.
pub struct BaseRouteTableRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fdomain_client::fidl::RequestStream for BaseRouteTableRequestStream {
    type Protocol = BaseRouteTableMarker;
    type ControlHandle = BaseRouteTableControlHandle;

    fn from_channel(channel: fdomain_client::Channel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        BaseRouteTableControlHandle { inner: self.inner.clone() }
    }

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

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

impl futures::Stream for BaseRouteTableRequestStream {
    type Item = Result<BaseRouteTableRequest, 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 BaseRouteTableRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |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(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(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 {
                0x7eab30c55edbfc15 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseRouteTableControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseRouteTableRequest::GetTableId {
                        responder: BaseRouteTableGetTableIdResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x2853ab157285b384 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseRouteTableControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseRouteTableRequest::Detach {
                        control_handle,
                    })
                }
                0xc42e58a5fc79426 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseRouteTableControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseRouteTableRequest::Remove {
                        responder: BaseRouteTableRemoveResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x56a48c921ff3b6eb => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseRouteTableControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseRouteTableRequest::GetAuthorizationForRouteTable {
                        responder: BaseRouteTableGetAuthorizationForRouteTableResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <BaseRouteTableMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// Common base for `RouteTable` protocol that is IP version agnostic. This
/// helps reduce FIDL duplication.
#[derive(Debug)]
pub enum BaseRouteTableRequest {
    /// Gets the table ID for this table.
    GetTableId { responder: BaseRouteTableGetTableIdResponder },
    /// Detaches the lifetime of the route table from the lifetime of the
    /// client end of the channel.
    ///
    /// After this method is called, the route table will not be removed
    /// if the client end is closed. It's a no-op if called on the main table.
    Detach { control_handle: BaseRouteTableControlHandle },
    /// Removes the route table explicitly.
    ///
    /// This method cannot be called on the main table or an interface-local
    /// table, an error will be returned if called. The server will close the
    /// channel after this method successfully returns.
    Remove { responder: BaseRouteTableRemoveResponder },
    /// Gets an authentication credential for this table.
    ///
    /// The credential contains a [`zx::handle::EVENT`], whose duplicate is
    /// held by the server. This credential can be passed into
    /// `fuchsia.net.routes.admin` API calls to prove ownership of this route
    /// table. The `EVENT` is stable throughout the lifetime of the route table.
    /// Clients may duplicate this `EVENT` to make multiple API calls, or
    /// transfer the `EVENT` to other clients.
    ///
    /// - response `credential` the authorization credential for this table.
    GetAuthorizationForRouteTable {
        responder: BaseRouteTableGetAuthorizationForRouteTableResponder,
    },
}

impl BaseRouteTableRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_table_id(self) -> Option<(BaseRouteTableGetTableIdResponder)> {
        if let BaseRouteTableRequest::GetTableId { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_detach(self) -> Option<(BaseRouteTableControlHandle)> {
        if let BaseRouteTableRequest::Detach { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_remove(self) -> Option<(BaseRouteTableRemoveResponder)> {
        if let BaseRouteTableRequest::Remove { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_authorization_for_route_table(
        self,
    ) -> Option<(BaseRouteTableGetAuthorizationForRouteTableResponder)> {
        if let BaseRouteTableRequest::GetAuthorizationForRouteTable { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            BaseRouteTableRequest::GetTableId { .. } => "get_table_id",
            BaseRouteTableRequest::Detach { .. } => "detach",
            BaseRouteTableRequest::Remove { .. } => "remove",
            BaseRouteTableRequest::GetAuthorizationForRouteTable { .. } => {
                "get_authorization_for_route_table"
            }
        }
    }
}

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

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

impl fdomain_client::fidl::ControlHandle for BaseRouteTableControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

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

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fdomain_client::OnFDomainSignals {
        self.inner.channel().on_closed()
    }
}

impl BaseRouteTableControlHandle {}

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

/// Set the the channel to be shutdown (see [`BaseRouteTableControlHandle::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 BaseRouteTableGetTableIdResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for BaseRouteTableGetTableIdResponder {
    type ControlHandle = BaseRouteTableControlHandle;

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

    fn send_raw(&self, mut table_id: u32) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<BaseRouteTableGetTableIdResponse>(
            (table_id,),
            self.tx_id,
            0x7eab30c55edbfc15,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`BaseRouteTableControlHandle::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 BaseRouteTableRemoveResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for BaseRouteTableRemoveResponder {
    type ControlHandle = BaseRouteTableControlHandle;

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

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

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

/// Set the the channel to be shutdown (see [`BaseRouteTableControlHandle::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 BaseRouteTableGetAuthorizationForRouteTableResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for BaseRouteTableGetAuthorizationForRouteTableResponder {
    type ControlHandle = BaseRouteTableControlHandle;

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

    fn send_raw(&self, mut credential: GrantForRouteTableAuthorization) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<BaseRouteTableGetAuthorizationForRouteTableResponse>(
            (&mut credential,),
            self.tx_id,
            0x56a48c921ff3b6eb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fdomain_client::fidl::ProtocolMarker for BaseRuleSetMarker {
    type Proxy = BaseRuleSetProxy;
    type RequestStream = BaseRuleSetRequestStream;

    const DEBUG_NAME: &'static str = "(anonymous) BaseRuleSet";
}
pub type BaseRuleSetAuthenticateForRouteTableResult = Result<(), AuthenticateForRouteTableError>;
pub type BaseRuleSetRemoveRuleResult = Result<(), RuleSetError>;

pub trait BaseRuleSetProxyInterface: Send + Sync {
    type AuthenticateForRouteTableResponseFut: std::future::Future<
            Output = Result<BaseRuleSetAuthenticateForRouteTableResult, fidl::Error>,
        > + Send;
    fn r#authenticate_for_route_table(
        &self,
        table: u32,
        token: fdomain_client::Event,
    ) -> Self::AuthenticateForRouteTableResponseFut;
    type RemoveRuleResponseFut: std::future::Future<Output = Result<BaseRuleSetRemoveRuleResult, fidl::Error>>
        + Send;
    fn r#remove_rule(&self, index: u32) -> Self::RemoveRuleResponseFut;
    fn r#close(&self) -> Result<(), fidl::Error>;
}

#[derive(Debug, Clone)]
pub struct BaseRuleSetProxy {
    client: fidl::client::Client<fdomain_client::fidl::FDomainResourceDialect>,
}

impl fdomain_client::fidl::Proxy for BaseRuleSetProxy {
    type Protocol = BaseRuleSetMarker;

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

    fn into_channel(self) -> Result<fdomain_client::Channel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

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

impl BaseRuleSetProxy {
    /// Create a new Proxy for fuchsia.net.routes.admin/BaseRuleSet.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name = <BaseRuleSetMarker as fdomain_client::fidl::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) -> BaseRuleSetEventStream {
        BaseRuleSetEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Authenticates for a route table that will be used in an action.
    pub fn r#authenticate_for_route_table(
        &self,
        mut table: u32,
        mut token: fdomain_client::Event,
    ) -> fidl::client::QueryResponseFut<
        BaseRuleSetAuthenticateForRouteTableResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        BaseRuleSetProxyInterface::r#authenticate_for_route_table(self, table, token)
    }

    /// Removes a rule from this rule set.
    ///
    /// If the client tries to remove from an index that does not have a rule,
    /// the error `RULE_DOES_NOT_EXIST` will be returned.
    ///
    /// + request `index` the index of the rule.
    pub fn r#remove_rule(
        &self,
        mut index: u32,
    ) -> fidl::client::QueryResponseFut<
        BaseRuleSetRemoveRuleResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        BaseRuleSetProxyInterface::r#remove_rule(self, index)
    }

    /// Removes all rules in the rule set and the underlying channel will be
    /// closed after the rules are removed.
    ///
    /// This method provides a way for synchronous closure.
    pub fn r#close(&self) -> Result<(), fidl::Error> {
        BaseRuleSetProxyInterface::r#close(self)
    }
}

impl BaseRuleSetProxyInterface for BaseRuleSetProxy {
    type AuthenticateForRouteTableResponseFut = fidl::client::QueryResponseFut<
        BaseRuleSetAuthenticateForRouteTableResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#authenticate_for_route_table(
        &self,
        mut table: u32,
        mut token: fdomain_client::Event,
    ) -> Self::AuthenticateForRouteTableResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseRuleSetAuthenticateForRouteTableResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    AuthenticateForRouteTableError,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                0x6fd845360ed9bc8f,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            ProofOfRouteTableAuthorization,
            BaseRuleSetAuthenticateForRouteTableResult,
        >(
            (table, token,),
            0x6fd845360ed9bc8f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type RemoveRuleResponseFut = fidl::client::QueryResponseFut<
        BaseRuleSetRemoveRuleResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#remove_rule(&self, mut index: u32) -> Self::RemoveRuleResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseRuleSetRemoveRuleResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, RuleSetError>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x2ae3d7e817cbff90,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BaseRuleSetRemoveRuleRequest, BaseRuleSetRemoveRuleResult>(
                (index,),
                0x2ae3d7e817cbff90,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

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

pub struct BaseRuleSetEventStream {
    event_receiver: fidl::client::EventReceiver<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.net.routes.admin/BaseRuleSet.
pub struct BaseRuleSetRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fdomain_client::fidl::RequestStream for BaseRuleSetRequestStream {
    type Protocol = BaseRuleSetMarker;
    type ControlHandle = BaseRuleSetControlHandle;

    fn from_channel(channel: fdomain_client::Channel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        BaseRuleSetControlHandle { inner: self.inner.clone() }
    }

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

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

impl futures::Stream for BaseRuleSetRequestStream {
    type Item = Result<BaseRuleSetRequest, 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 BaseRuleSetRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |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(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(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 {
                    0x6fd845360ed9bc8f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ProofOfRouteTableAuthorization,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<ProofOfRouteTableAuthorization>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BaseRuleSetControlHandle { inner: this.inner.clone() };
                        Ok(BaseRuleSetRequest::AuthenticateForRouteTable {
                            table: req.table,
                            token: req.token,

                            responder: BaseRuleSetAuthenticateForRouteTableResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2ae3d7e817cbff90 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseRuleSetRemoveRuleRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<BaseRuleSetRemoveRuleRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BaseRuleSetControlHandle { inner: this.inner.clone() };
                        Ok(BaseRuleSetRequest::RemoveRule {
                            index: req.index,

                            responder: BaseRuleSetRemoveRuleResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x457e1753672d4073 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BaseRuleSetControlHandle { inner: this.inner.clone() };
                        Ok(BaseRuleSetRequest::Close { control_handle })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <BaseRuleSetMarker as fdomain_client::fidl::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Common base for `RuleSet` protocol that is IP version agnostic. This
/// helps reduce FIDL duplication.
#[derive(Debug)]
pub enum BaseRuleSetRequest {
    /// Authenticates for a route table that will be used in an action.
    AuthenticateForRouteTable {
        table: u32,
        token: fdomain_client::Event,
        responder: BaseRuleSetAuthenticateForRouteTableResponder,
    },
    /// Removes a rule from this rule set.
    ///
    /// If the client tries to remove from an index that does not have a rule,
    /// the error `RULE_DOES_NOT_EXIST` will be returned.
    ///
    /// + request `index` the index of the rule.
    RemoveRule { index: u32, responder: BaseRuleSetRemoveRuleResponder },
    /// Removes all rules in the rule set and the underlying channel will be
    /// closed after the rules are removed.
    ///
    /// This method provides a way for synchronous closure.
    Close { control_handle: BaseRuleSetControlHandle },
}

impl BaseRuleSetRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_authenticate_for_route_table(
        self,
    ) -> Option<(u32, fdomain_client::Event, BaseRuleSetAuthenticateForRouteTableResponder)> {
        if let BaseRuleSetRequest::AuthenticateForRouteTable { table, token, responder } = self {
            Some((table, token, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_remove_rule(self) -> Option<(u32, BaseRuleSetRemoveRuleResponder)> {
        if let BaseRuleSetRequest::RemoveRule { index, responder } = self {
            Some((index, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_close(self) -> Option<(BaseRuleSetControlHandle)> {
        if let BaseRuleSetRequest::Close { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            BaseRuleSetRequest::AuthenticateForRouteTable { .. } => "authenticate_for_route_table",
            BaseRuleSetRequest::RemoveRule { .. } => "remove_rule",
            BaseRuleSetRequest::Close { .. } => "close",
        }
    }
}

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

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

impl fdomain_client::fidl::ControlHandle for BaseRuleSetControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

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

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fdomain_client::OnFDomainSignals {
        self.inner.channel().on_closed()
    }
}

impl BaseRuleSetControlHandle {}

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

/// Set the the channel to be shutdown (see [`BaseRuleSetControlHandle::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 BaseRuleSetAuthenticateForRouteTableResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for BaseRuleSetAuthenticateForRouteTableResponder {
    type ControlHandle = BaseRuleSetControlHandle;

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

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

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

/// Set the the channel to be shutdown (see [`BaseRuleSetControlHandle::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 BaseRuleSetRemoveRuleResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for BaseRuleSetRemoveRuleResponder {
    type ControlHandle = BaseRuleSetControlHandle;

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

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

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

impl fdomain_client::fidl::ProtocolMarker for RouteSetV4Marker {
    type Proxy = RouteSetV4Proxy;
    type RequestStream = RouteSetV4RequestStream;

    const DEBUG_NAME: &'static str = "(anonymous) RouteSetV4";
}
pub type RouteSetV4AuthenticateForInterfaceResult = Result<(), AuthenticateForInterfaceError>;
pub type RouteSetV4AddRouteResult = Result<bool, RouteSetError>;
pub type RouteSetV4RemoveRouteResult = Result<bool, RouteSetError>;

pub trait RouteSetV4ProxyInterface: Send + Sync {
    type AuthenticateForInterfaceResponseFut: std::future::Future<Output = Result<RouteSetV4AuthenticateForInterfaceResult, fidl::Error>>
        + Send;
    fn r#authenticate_for_interface(
        &self,
        credential: fdomain_fuchsia_net_resources::ProofOfInterfaceAuthorization,
    ) -> Self::AuthenticateForInterfaceResponseFut;
    type AddRouteResponseFut: std::future::Future<Output = Result<RouteSetV4AddRouteResult, fidl::Error>>
        + Send;
    fn r#add_route(&self, route: &fdomain_fuchsia_net_routes::RouteV4)
    -> Self::AddRouteResponseFut;
    type RemoveRouteResponseFut: std::future::Future<Output = Result<RouteSetV4RemoveRouteResult, fidl::Error>>
        + Send;
    fn r#remove_route(
        &self,
        route: &fdomain_fuchsia_net_routes::RouteV4,
    ) -> Self::RemoveRouteResponseFut;
}

#[derive(Debug, Clone)]
pub struct RouteSetV4Proxy {
    client: fidl::client::Client<fdomain_client::fidl::FDomainResourceDialect>,
}

impl fdomain_client::fidl::Proxy for RouteSetV4Proxy {
    type Protocol = RouteSetV4Marker;

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

    fn into_channel(self) -> Result<fdomain_client::Channel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

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

impl RouteSetV4Proxy {
    /// Create a new Proxy for fuchsia.net.routes.admin/RouteSetV4.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name = <RouteSetV4Marker as fdomain_client::fidl::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) -> RouteSetV4EventStream {
        RouteSetV4EventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Authenticate this route set to manage routes on the provided interface.
    /// Authentication is valid for the lifetime of the route set.
    ///
    /// + request `interface` the authentication credential for an interface.
    pub fn r#authenticate_for_interface(
        &self,
        mut credential: fdomain_fuchsia_net_resources::ProofOfInterfaceAuthorization,
    ) -> fidl::client::QueryResponseFut<
        RouteSetV4AuthenticateForInterfaceResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        RouteSetV4ProxyInterface::r#authenticate_for_interface(self, credential)
    }

    /// Adds a route to this route set.
    ///
    /// + request `route` the route to add.
    /// - response `did_add` true iff the route was added to this `RouteSet`
    ///            as a result of this call.
    pub fn r#add_route(
        &self,
        mut route: &fdomain_fuchsia_net_routes::RouteV4,
    ) -> fidl::client::QueryResponseFut<
        RouteSetV4AddRouteResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        RouteSetV4ProxyInterface::r#add_route(self, route)
    }

    /// Removes a route from this route set.
    ///
    /// Note that if this route also exists other route sets, it will not be
    /// removed from the global routing table.
    ///
    /// + request `route` the route to remove.
    /// - response `did_remove` true iff the route was removed from this
    ///            `RouteSet` as a result of this call.
    pub fn r#remove_route(
        &self,
        mut route: &fdomain_fuchsia_net_routes::RouteV4,
    ) -> fidl::client::QueryResponseFut<
        RouteSetV4RemoveRouteResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        RouteSetV4ProxyInterface::r#remove_route(self, route)
    }
}

impl RouteSetV4ProxyInterface for RouteSetV4Proxy {
    type AuthenticateForInterfaceResponseFut = fidl::client::QueryResponseFut<
        RouteSetV4AuthenticateForInterfaceResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#authenticate_for_interface(
        &self,
        mut credential: fdomain_fuchsia_net_resources::ProofOfInterfaceAuthorization,
    ) -> Self::AuthenticateForInterfaceResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RouteSetV4AuthenticateForInterfaceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    AuthenticateForInterfaceError,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                0x74841ceef127518e,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            RouteSetV4AuthenticateForInterfaceRequest,
            RouteSetV4AuthenticateForInterfaceResult,
        >(
            (&mut credential,),
            0x74841ceef127518e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type AddRouteResponseFut = fidl::client::QueryResponseFut<
        RouteSetV4AddRouteResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#add_route(
        &self,
        mut route: &fdomain_fuchsia_net_routes::RouteV4,
    ) -> Self::AddRouteResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RouteSetV4AddRouteResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<RouteSetV4AddRouteResponse, RouteSetError>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x4bd69e45539e8ec0,
            >(_buf?)?;
            Ok(_response.map(|x| x.did_add))
        }
        self.client.send_query_and_decode::<RouteSetV4AddRouteRequest, RouteSetV4AddRouteResult>(
            (route,),
            0x4bd69e45539e8ec0,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type RemoveRouteResponseFut = fidl::client::QueryResponseFut<
        RouteSetV4RemoveRouteResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#remove_route(
        &self,
        mut route: &fdomain_fuchsia_net_routes::RouteV4,
    ) -> Self::RemoveRouteResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RouteSetV4RemoveRouteResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<RouteSetV4RemoveRouteResponse, RouteSetError>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x514f6880232f1665,
            >(_buf?)?;
            Ok(_response.map(|x| x.did_remove))
        }
        self.client
            .send_query_and_decode::<RouteSetV4RemoveRouteRequest, RouteSetV4RemoveRouteResult>(
                (route,),
                0x514f6880232f1665,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }
}

pub struct RouteSetV4EventStream {
    event_receiver: fidl::client::EventReceiver<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.net.routes.admin/RouteSetV4.
pub struct RouteSetV4RequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fdomain_client::fidl::RequestStream for RouteSetV4RequestStream {
    type Protocol = RouteSetV4Marker;
    type ControlHandle = RouteSetV4ControlHandle;

    fn from_channel(channel: fdomain_client::Channel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        RouteSetV4ControlHandle { inner: self.inner.clone() }
    }

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

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

impl futures::Stream for RouteSetV4RequestStream {
    type Item = Result<RouteSetV4Request, 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 RouteSetV4RequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |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(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(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 {
                    0x74841ceef127518e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RouteSetV4AuthenticateForInterfaceRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<RouteSetV4AuthenticateForInterfaceRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RouteSetV4ControlHandle { inner: this.inner.clone() };
                        Ok(RouteSetV4Request::AuthenticateForInterface {
                            credential: req.credential,

                            responder: RouteSetV4AuthenticateForInterfaceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4bd69e45539e8ec0 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RouteSetV4AddRouteRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<RouteSetV4AddRouteRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RouteSetV4ControlHandle { inner: this.inner.clone() };
                        Ok(RouteSetV4Request::AddRoute {
                            route: req.route,

                            responder: RouteSetV4AddRouteResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x514f6880232f1665 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RouteSetV4RemoveRouteRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<RouteSetV4RemoveRouteRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RouteSetV4ControlHandle { inner: this.inner.clone() };
                        Ok(RouteSetV4Request::RemoveRoute {
                            route: req.route,

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

/// Provides mutable access over a set of system's IPv4 routes.
///
/// The system maintains a single global routing table. A route set offers an
/// isolated window into a subset of the global routing table: clients are free
/// to manage the routes within their own route set, but not the route set of
/// others. Thus the global routing table represents the union of all existing
/// route sets. A route must be removed from all route sets to which it belongs
/// before it will be removed from the global table.
///
/// This protocol encodes the lifetime of the route set. Closing the client end
/// removes the route set, and will also remove any routes that were
/// solely-owned by this route set.
///
/// Note that the system reserves the right to remove routes out from underneath
/// this route set. This will always manifest as a `removed` event on the
/// [`fuchsia.net.routes/WatcherV4`] protocol.
///
/// If the route table backing this route set is removed, then this protocol
/// will be closed with a `ZX_ERR_UNAVAILABLE` epitaph.
#[derive(Debug)]
pub enum RouteSetV4Request {
    /// Authenticate this route set to manage routes on the provided interface.
    /// Authentication is valid for the lifetime of the route set.
    ///
    /// + request `interface` the authentication credential for an interface.
    AuthenticateForInterface {
        credential: fdomain_fuchsia_net_resources::ProofOfInterfaceAuthorization,
        responder: RouteSetV4AuthenticateForInterfaceResponder,
    },
    /// Adds a route to this route set.
    ///
    /// + request `route` the route to add.
    /// - response `did_add` true iff the route was added to this `RouteSet`
    ///            as a result of this call.
    AddRoute { route: fdomain_fuchsia_net_routes::RouteV4, responder: RouteSetV4AddRouteResponder },
    /// Removes a route from this route set.
    ///
    /// Note that if this route also exists other route sets, it will not be
    /// removed from the global routing table.
    ///
    /// + request `route` the route to remove.
    /// - response `did_remove` true iff the route was removed from this
    ///            `RouteSet` as a result of this call.
    RemoveRoute {
        route: fdomain_fuchsia_net_routes::RouteV4,
        responder: RouteSetV4RemoveRouteResponder,
    },
}

impl RouteSetV4Request {
    #[allow(irrefutable_let_patterns)]
    pub fn into_authenticate_for_interface(
        self,
    ) -> Option<(
        fdomain_fuchsia_net_resources::ProofOfInterfaceAuthorization,
        RouteSetV4AuthenticateForInterfaceResponder,
    )> {
        if let RouteSetV4Request::AuthenticateForInterface { credential, responder } = self {
            Some((credential, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_route(
        self,
    ) -> Option<(fdomain_fuchsia_net_routes::RouteV4, RouteSetV4AddRouteResponder)> {
        if let RouteSetV4Request::AddRoute { route, responder } = self {
            Some((route, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_remove_route(
        self,
    ) -> Option<(fdomain_fuchsia_net_routes::RouteV4, RouteSetV4RemoveRouteResponder)> {
        if let RouteSetV4Request::RemoveRoute { route, responder } = self {
            Some((route, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            RouteSetV4Request::AuthenticateForInterface { .. } => "authenticate_for_interface",
            RouteSetV4Request::AddRoute { .. } => "add_route",
            RouteSetV4Request::RemoveRoute { .. } => "remove_route",
        }
    }
}

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

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

impl fdomain_client::fidl::ControlHandle for RouteSetV4ControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

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

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fdomain_client::OnFDomainSignals {
        self.inner.channel().on_closed()
    }
}

impl RouteSetV4ControlHandle {}

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

/// Set the the channel to be shutdown (see [`RouteSetV4ControlHandle::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 RouteSetV4AuthenticateForInterfaceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for RouteSetV4AuthenticateForInterfaceResponder {
    type ControlHandle = RouteSetV4ControlHandle;

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

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

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

/// Set the the channel to be shutdown (see [`RouteSetV4ControlHandle::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 RouteSetV4AddRouteResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for RouteSetV4AddRouteResponder {
    type ControlHandle = RouteSetV4ControlHandle;

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

    fn send_raw(&self, mut result: Result<bool, RouteSetError>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            RouteSetV4AddRouteResponse,
            RouteSetError,
        >>(
            result.map(|did_add| (did_add,)),
            self.tx_id,
            0x4bd69e45539e8ec0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`RouteSetV4ControlHandle::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 RouteSetV4RemoveRouteResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for RouteSetV4RemoveRouteResponder {
    type ControlHandle = RouteSetV4ControlHandle;

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

    fn send_raw(&self, mut result: Result<bool, RouteSetError>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            RouteSetV4RemoveRouteResponse,
            RouteSetError,
        >>(
            result.map(|did_remove| (did_remove,)),
            self.tx_id,
            0x514f6880232f1665,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fdomain_client::fidl::ProtocolMarker for RouteSetV6Marker {
    type Proxy = RouteSetV6Proxy;
    type RequestStream = RouteSetV6RequestStream;

    const DEBUG_NAME: &'static str = "(anonymous) RouteSetV6";
}
pub type RouteSetV6AuthenticateForInterfaceResult = Result<(), AuthenticateForInterfaceError>;
pub type RouteSetV6AddRouteResult = Result<bool, RouteSetError>;
pub type RouteSetV6RemoveRouteResult = Result<bool, RouteSetError>;

pub trait RouteSetV6ProxyInterface: Send + Sync {
    type AuthenticateForInterfaceResponseFut: std::future::Future<Output = Result<RouteSetV6AuthenticateForInterfaceResult, fidl::Error>>
        + Send;
    fn r#authenticate_for_interface(
        &self,
        credential: fdomain_fuchsia_net_resources::ProofOfInterfaceAuthorization,
    ) -> Self::AuthenticateForInterfaceResponseFut;
    type AddRouteResponseFut: std::future::Future<Output = Result<RouteSetV6AddRouteResult, fidl::Error>>
        + Send;
    fn r#add_route(&self, route: &fdomain_fuchsia_net_routes::RouteV6)
    -> Self::AddRouteResponseFut;
    type RemoveRouteResponseFut: std::future::Future<Output = Result<RouteSetV6RemoveRouteResult, fidl::Error>>
        + Send;
    fn r#remove_route(
        &self,
        route: &fdomain_fuchsia_net_routes::RouteV6,
    ) -> Self::RemoveRouteResponseFut;
}

#[derive(Debug, Clone)]
pub struct RouteSetV6Proxy {
    client: fidl::client::Client<fdomain_client::fidl::FDomainResourceDialect>,
}

impl fdomain_client::fidl::Proxy for RouteSetV6Proxy {
    type Protocol = RouteSetV6Marker;

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

    fn into_channel(self) -> Result<fdomain_client::Channel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

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

impl RouteSetV6Proxy {
    /// Create a new Proxy for fuchsia.net.routes.admin/RouteSetV6.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name = <RouteSetV6Marker as fdomain_client::fidl::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) -> RouteSetV6EventStream {
        RouteSetV6EventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Authenticate this route set to manage routes on the provided interface.
    /// Authentication is valid for the lifetime of the route set.
    ///
    /// + request `interface` the authentication credential for an interface.
    pub fn r#authenticate_for_interface(
        &self,
        mut credential: fdomain_fuchsia_net_resources::ProofOfInterfaceAuthorization,
    ) -> fidl::client::QueryResponseFut<
        RouteSetV6AuthenticateForInterfaceResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        RouteSetV6ProxyInterface::r#authenticate_for_interface(self, credential)
    }

    /// Adds a route to this route set.
    ///
    /// + request `route` the route to add.
    /// - response `did_add` true iff the route was added to this `RouteSet`
    ///            as a result of this call.
    pub fn r#add_route(
        &self,
        mut route: &fdomain_fuchsia_net_routes::RouteV6,
    ) -> fidl::client::QueryResponseFut<
        RouteSetV6AddRouteResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        RouteSetV6ProxyInterface::r#add_route(self, route)
    }

    /// Removes a route from this route set.
    ///
    /// Note that if this route also exists other route sets, it will not be
    /// removed from the global routing table.
    ///
    /// + request `route` the route to remove.
    /// - response `did_remove` true iff the route was removed from this
    ///            `RouteSet` as a result of this call.
    pub fn r#remove_route(
        &self,
        mut route: &fdomain_fuchsia_net_routes::RouteV6,
    ) -> fidl::client::QueryResponseFut<
        RouteSetV6RemoveRouteResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        RouteSetV6ProxyInterface::r#remove_route(self, route)
    }
}

impl RouteSetV6ProxyInterface for RouteSetV6Proxy {
    type AuthenticateForInterfaceResponseFut = fidl::client::QueryResponseFut<
        RouteSetV6AuthenticateForInterfaceResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#authenticate_for_interface(
        &self,
        mut credential: fdomain_fuchsia_net_resources::ProofOfInterfaceAuthorization,
    ) -> Self::AuthenticateForInterfaceResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RouteSetV6AuthenticateForInterfaceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    AuthenticateForInterfaceError,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                0x7d63a6a7aed6f640,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            RouteSetV6AuthenticateForInterfaceRequest,
            RouteSetV6AuthenticateForInterfaceResult,
        >(
            (&mut credential,),
            0x7d63a6a7aed6f640,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type AddRouteResponseFut = fidl::client::QueryResponseFut<
        RouteSetV6AddRouteResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#add_route(
        &self,
        mut route: &fdomain_fuchsia_net_routes::RouteV6,
    ) -> Self::AddRouteResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RouteSetV6AddRouteResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<RouteSetV6AddRouteResponse, RouteSetError>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x67a2bd2ee34ace2e,
            >(_buf?)?;
            Ok(_response.map(|x| x.did_add))
        }
        self.client.send_query_and_decode::<RouteSetV6AddRouteRequest, RouteSetV6AddRouteResult>(
            (route,),
            0x67a2bd2ee34ace2e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type RemoveRouteResponseFut = fidl::client::QueryResponseFut<
        RouteSetV6RemoveRouteResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#remove_route(
        &self,
        mut route: &fdomain_fuchsia_net_routes::RouteV6,
    ) -> Self::RemoveRouteResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RouteSetV6RemoveRouteResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<RouteSetV6RemoveRouteResponse, RouteSetError>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x4e5b7d4b1112cd82,
            >(_buf?)?;
            Ok(_response.map(|x| x.did_remove))
        }
        self.client
            .send_query_and_decode::<RouteSetV6RemoveRouteRequest, RouteSetV6RemoveRouteResult>(
                (route,),
                0x4e5b7d4b1112cd82,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }
}

pub struct RouteSetV6EventStream {
    event_receiver: fidl::client::EventReceiver<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.net.routes.admin/RouteSetV6.
pub struct RouteSetV6RequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fdomain_client::fidl::RequestStream for RouteSetV6RequestStream {
    type Protocol = RouteSetV6Marker;
    type ControlHandle = RouteSetV6ControlHandle;

    fn from_channel(channel: fdomain_client::Channel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        RouteSetV6ControlHandle { inner: self.inner.clone() }
    }

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

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

impl futures::Stream for RouteSetV6RequestStream {
    type Item = Result<RouteSetV6Request, 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 RouteSetV6RequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |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(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(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 {
                    0x7d63a6a7aed6f640 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RouteSetV6AuthenticateForInterfaceRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<RouteSetV6AuthenticateForInterfaceRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RouteSetV6ControlHandle { inner: this.inner.clone() };
                        Ok(RouteSetV6Request::AuthenticateForInterface {
                            credential: req.credential,

                            responder: RouteSetV6AuthenticateForInterfaceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x67a2bd2ee34ace2e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RouteSetV6AddRouteRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<RouteSetV6AddRouteRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RouteSetV6ControlHandle { inner: this.inner.clone() };
                        Ok(RouteSetV6Request::AddRoute {
                            route: req.route,

                            responder: RouteSetV6AddRouteResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4e5b7d4b1112cd82 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RouteSetV6RemoveRouteRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<RouteSetV6RemoveRouteRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RouteSetV6ControlHandle { inner: this.inner.clone() };
                        Ok(RouteSetV6Request::RemoveRoute {
                            route: req.route,

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

/// Provides mutable access over a set of system's IPv6 routes.
///
/// The system maintains a single global routing table. A route set offers an
/// isolated window into a subset of the global routing table: clients are free
/// to manage the routes within their own route set, but not the route set of
/// others. Thus the global routing table represents the union of all existing
/// route sets. A route must be removed from all route sets to which it belongs
/// before it will be removed from the global table.
///
/// This protocol encodes the lifetime of the route set. Closing the client end
/// removes the route set, and will also remove any routes that were
/// solely-owned by this route set.
///
/// Note that the system reserves the right to remove routes out from underneath
/// this route set. This will always manifest as a `removed` event on the
/// [`fuchsia.net.routes/WatcherV6`] protocol.
///
/// If the route table backing this route set is removed, then this protocol
/// will be closed with a `ZX_ERR_UNAVAILABLE` epitaph.
#[derive(Debug)]
pub enum RouteSetV6Request {
    /// Authenticate this route set to manage routes on the provided interface.
    /// Authentication is valid for the lifetime of the route set.
    ///
    /// + request `interface` the authentication credential for an interface.
    AuthenticateForInterface {
        credential: fdomain_fuchsia_net_resources::ProofOfInterfaceAuthorization,
        responder: RouteSetV6AuthenticateForInterfaceResponder,
    },
    /// Adds a route to this route set.
    ///
    /// + request `route` the route to add.
    /// - response `did_add` true iff the route was added to this `RouteSet`
    ///            as a result of this call.
    AddRoute { route: fdomain_fuchsia_net_routes::RouteV6, responder: RouteSetV6AddRouteResponder },
    /// Removes a route from this route set.
    ///
    /// Note that if this route also exists other route sets, it will not be
    /// removed from the global routing table.
    ///
    /// + request `route` the route to remove.
    /// - response `did_remove` true iff the route was removed from this
    ///            `RouteSet` as a result of this call.
    RemoveRoute {
        route: fdomain_fuchsia_net_routes::RouteV6,
        responder: RouteSetV6RemoveRouteResponder,
    },
}

impl RouteSetV6Request {
    #[allow(irrefutable_let_patterns)]
    pub fn into_authenticate_for_interface(
        self,
    ) -> Option<(
        fdomain_fuchsia_net_resources::ProofOfInterfaceAuthorization,
        RouteSetV6AuthenticateForInterfaceResponder,
    )> {
        if let RouteSetV6Request::AuthenticateForInterface { credential, responder } = self {
            Some((credential, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_route(
        self,
    ) -> Option<(fdomain_fuchsia_net_routes::RouteV6, RouteSetV6AddRouteResponder)> {
        if let RouteSetV6Request::AddRoute { route, responder } = self {
            Some((route, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_remove_route(
        self,
    ) -> Option<(fdomain_fuchsia_net_routes::RouteV6, RouteSetV6RemoveRouteResponder)> {
        if let RouteSetV6Request::RemoveRoute { route, responder } = self {
            Some((route, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            RouteSetV6Request::AuthenticateForInterface { .. } => "authenticate_for_interface",
            RouteSetV6Request::AddRoute { .. } => "add_route",
            RouteSetV6Request::RemoveRoute { .. } => "remove_route",
        }
    }
}

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

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

impl fdomain_client::fidl::ControlHandle for RouteSetV6ControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

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

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fdomain_client::OnFDomainSignals {
        self.inner.channel().on_closed()
    }
}

impl RouteSetV6ControlHandle {}

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

/// Set the the channel to be shutdown (see [`RouteSetV6ControlHandle::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 RouteSetV6AuthenticateForInterfaceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for RouteSetV6AuthenticateForInterfaceResponder {
    type ControlHandle = RouteSetV6ControlHandle;

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

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

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

/// Set the the channel to be shutdown (see [`RouteSetV6ControlHandle::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 RouteSetV6AddRouteResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for RouteSetV6AddRouteResponder {
    type ControlHandle = RouteSetV6ControlHandle;

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

    fn send_raw(&self, mut result: Result<bool, RouteSetError>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            RouteSetV6AddRouteResponse,
            RouteSetError,
        >>(
            result.map(|did_add| (did_add,)),
            self.tx_id,
            0x67a2bd2ee34ace2e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`RouteSetV6ControlHandle::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 RouteSetV6RemoveRouteResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for RouteSetV6RemoveRouteResponder {
    type ControlHandle = RouteSetV6ControlHandle;

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

    fn send_raw(&self, mut result: Result<bool, RouteSetError>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            RouteSetV6RemoveRouteResponse,
            RouteSetError,
        >>(
            result.map(|did_remove| (did_remove,)),
            self.tx_id,
            0x4e5b7d4b1112cd82,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fdomain_client::fidl::ProtocolMarker for RouteTableProviderV4Marker {
    type Proxy = RouteTableProviderV4Proxy;
    type RequestStream = RouteTableProviderV4RequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.net.routes.admin.RouteTableProviderV4";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for RouteTableProviderV4Marker {}
pub type RouteTableProviderV4GetInterfaceLocalTableResult =
    Result<fdomain_client::fidl::ClientEnd<RouteTableV4Marker>, GetInterfaceLocalTableError>;

pub trait RouteTableProviderV4ProxyInterface: Send + Sync {
    fn r#new_route_table(
        &self,
        provider: fdomain_client::fidl::ServerEnd<RouteTableV4Marker>,
        options: &RouteTableOptionsV4,
    ) -> Result<(), fidl::Error>;
    type GetInterfaceLocalTableResponseFut: std::future::Future<
            Output = Result<RouteTableProviderV4GetInterfaceLocalTableResult, fidl::Error>,
        > + Send;
    fn r#get_interface_local_table(
        &self,
        credential: fdomain_fuchsia_net_resources::ProofOfInterfaceAuthorization,
    ) -> Self::GetInterfaceLocalTableResponseFut;
}

#[derive(Debug, Clone)]
pub struct RouteTableProviderV4Proxy {
    client: fidl::client::Client<fdomain_client::fidl::FDomainResourceDialect>,
}

impl fdomain_client::fidl::Proxy for RouteTableProviderV4Proxy {
    type Protocol = RouteTableProviderV4Marker;

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

    fn into_channel(self) -> Result<fdomain_client::Channel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

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

impl RouteTableProviderV4Proxy {
    /// Create a new Proxy for fuchsia.net.routes.admin/RouteTableProviderV4.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name =
            <RouteTableProviderV4Marker as fdomain_client::fidl::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) -> RouteTableProviderV4EventStream {
        RouteTableProviderV4EventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Creates a new route table. If the client end of the `provider` is
    /// closed, the route table is removed (unless detached).
    pub fn r#new_route_table(
        &self,
        mut provider: fdomain_client::fidl::ServerEnd<RouteTableV4Marker>,
        mut options: &RouteTableOptionsV4,
    ) -> Result<(), fidl::Error> {
        RouteTableProviderV4ProxyInterface::r#new_route_table(self, provider, options)
    }

    /// Gets the interface-local route table for this interface.
    ///
    /// + request credential of the interface to get local route table.
    /// - response client end of the `RouteTableV4` protocol if successfully.
    ///
    /// This table is only removed after the interface is removed AND all
    /// outstanding `RouteTableV4` channels are closed.
    ///
    /// Calling detach on the route table is a no-op.
    pub fn r#get_interface_local_table(
        &self,
        mut credential: fdomain_fuchsia_net_resources::ProofOfInterfaceAuthorization,
    ) -> fidl::client::QueryResponseFut<
        RouteTableProviderV4GetInterfaceLocalTableResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        RouteTableProviderV4ProxyInterface::r#get_interface_local_table(self, credential)
    }
}

impl RouteTableProviderV4ProxyInterface for RouteTableProviderV4Proxy {
    fn r#new_route_table(
        &self,
        mut provider: fdomain_client::fidl::ServerEnd<RouteTableV4Marker>,
        mut options: &RouteTableOptionsV4,
    ) -> Result<(), fidl::Error> {
        self.client.send::<RouteTableProviderV4NewRouteTableRequest>(
            (provider, options),
            0x703bc0eaf98f07cf,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type GetInterfaceLocalTableResponseFut = fidl::client::QueryResponseFut<
        RouteTableProviderV4GetInterfaceLocalTableResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_interface_local_table(
        &self,
        mut credential: fdomain_fuchsia_net_resources::ProofOfInterfaceAuthorization,
    ) -> Self::GetInterfaceLocalTableResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RouteTableProviderV4GetInterfaceLocalTableResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    RouteTableProviderV4GetInterfaceLocalTableResponse,
                    GetInterfaceLocalTableError,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                0x2596721a63bbacbd,
            >(_buf?)?;
            Ok(_response.map(|x| x.route_table))
        }
        self.client.send_query_and_decode::<
            RouteTableProviderV4GetInterfaceLocalTableRequest,
            RouteTableProviderV4GetInterfaceLocalTableResult,
        >(
            (&mut credential,),
            0x2596721a63bbacbd,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

pub struct RouteTableProviderV4EventStream {
    event_receiver: fidl::client::EventReceiver<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.net.routes.admin/RouteTableProviderV4.
pub struct RouteTableProviderV4RequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fdomain_client::fidl::RequestStream for RouteTableProviderV4RequestStream {
    type Protocol = RouteTableProviderV4Marker;
    type ControlHandle = RouteTableProviderV4ControlHandle;

    fn from_channel(channel: fdomain_client::Channel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        RouteTableProviderV4ControlHandle { inner: self.inner.clone() }
    }

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

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

impl futures::Stream for RouteTableProviderV4RequestStream {
    type Item = Result<RouteTableProviderV4Request, 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 RouteTableProviderV4RequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |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(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(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 {
                0x703bc0eaf98f07cf => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(RouteTableProviderV4NewRouteTableRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<RouteTableProviderV4NewRouteTableRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = RouteTableProviderV4ControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(RouteTableProviderV4Request::NewRouteTable {provider: req.provider,
options: req.options,

                        control_handle,
                    })
                }
                0x2596721a63bbacbd => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(RouteTableProviderV4GetInterfaceLocalTableRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<RouteTableProviderV4GetInterfaceLocalTableRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = RouteTableProviderV4ControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(RouteTableProviderV4Request::GetInterfaceLocalTable {credential: req.credential,

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

/// This protocol allows the client to create route tables.
#[derive(Debug)]
pub enum RouteTableProviderV4Request {
    /// Creates a new route table. If the client end of the `provider` is
    /// closed, the route table is removed (unless detached).
    NewRouteTable {
        provider: fdomain_client::fidl::ServerEnd<RouteTableV4Marker>,
        options: RouteTableOptionsV4,
        control_handle: RouteTableProviderV4ControlHandle,
    },
    /// Gets the interface-local route table for this interface.
    ///
    /// + request credential of the interface to get local route table.
    /// - response client end of the `RouteTableV4` protocol if successfully.
    ///
    /// This table is only removed after the interface is removed AND all
    /// outstanding `RouteTableV4` channels are closed.
    ///
    /// Calling detach on the route table is a no-op.
    GetInterfaceLocalTable {
        credential: fdomain_fuchsia_net_resources::ProofOfInterfaceAuthorization,
        responder: RouteTableProviderV4GetInterfaceLocalTableResponder,
    },
}

impl RouteTableProviderV4Request {
    #[allow(irrefutable_let_patterns)]
    pub fn into_new_route_table(
        self,
    ) -> Option<(
        fdomain_client::fidl::ServerEnd<RouteTableV4Marker>,
        RouteTableOptionsV4,
        RouteTableProviderV4ControlHandle,
    )> {
        if let RouteTableProviderV4Request::NewRouteTable { provider, options, control_handle } =
            self
        {
            Some((provider, options, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_interface_local_table(
        self,
    ) -> Option<(
        fdomain_fuchsia_net_resources::ProofOfInterfaceAuthorization,
        RouteTableProviderV4GetInterfaceLocalTableResponder,
    )> {
        if let RouteTableProviderV4Request::GetInterfaceLocalTable { credential, responder } = self
        {
            Some((credential, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            RouteTableProviderV4Request::NewRouteTable { .. } => "new_route_table",
            RouteTableProviderV4Request::GetInterfaceLocalTable { .. } => {
                "get_interface_local_table"
            }
        }
    }
}

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

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

impl fdomain_client::fidl::ControlHandle for RouteTableProviderV4ControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

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

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fdomain_client::OnFDomainSignals {
        self.inner.channel().on_closed()
    }
}

impl RouteTableProviderV4ControlHandle {}

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

/// Set the the channel to be shutdown (see [`RouteTableProviderV4ControlHandle::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 RouteTableProviderV4GetInterfaceLocalTableResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for RouteTableProviderV4GetInterfaceLocalTableResponder {
    type ControlHandle = RouteTableProviderV4ControlHandle;

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

    fn send_raw(
        &self,
        mut result: Result<
            fdomain_client::fidl::ClientEnd<RouteTableV4Marker>,
            GetInterfaceLocalTableError,
        >,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            RouteTableProviderV4GetInterfaceLocalTableResponse,
            GetInterfaceLocalTableError,
        >>(
            result.map(|route_table| (route_table,)),
            self.tx_id,
            0x2596721a63bbacbd,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fdomain_client::fidl::ProtocolMarker for RouteTableProviderV6Marker {
    type Proxy = RouteTableProviderV6Proxy;
    type RequestStream = RouteTableProviderV6RequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.net.routes.admin.RouteTableProviderV6";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for RouteTableProviderV6Marker {}
pub type RouteTableProviderV6GetInterfaceLocalTableResult =
    Result<fdomain_client::fidl::ClientEnd<RouteTableV6Marker>, GetInterfaceLocalTableError>;

pub trait RouteTableProviderV6ProxyInterface: Send + Sync {
    fn r#new_route_table(
        &self,
        provider: fdomain_client::fidl::ServerEnd<RouteTableV6Marker>,
        options: &RouteTableOptionsV6,
    ) -> Result<(), fidl::Error>;
    type GetInterfaceLocalTableResponseFut: std::future::Future<
            Output = Result<RouteTableProviderV6GetInterfaceLocalTableResult, fidl::Error>,
        > + Send;
    fn r#get_interface_local_table(
        &self,
        credential: fdomain_fuchsia_net_resources::ProofOfInterfaceAuthorization,
    ) -> Self::GetInterfaceLocalTableResponseFut;
}

#[derive(Debug, Clone)]
pub struct RouteTableProviderV6Proxy {
    client: fidl::client::Client<fdomain_client::fidl::FDomainResourceDialect>,
}

impl fdomain_client::fidl::Proxy for RouteTableProviderV6Proxy {
    type Protocol = RouteTableProviderV6Marker;

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

    fn into_channel(self) -> Result<fdomain_client::Channel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

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

impl RouteTableProviderV6Proxy {
    /// Create a new Proxy for fuchsia.net.routes.admin/RouteTableProviderV6.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name =
            <RouteTableProviderV6Marker as fdomain_client::fidl::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) -> RouteTableProviderV6EventStream {
        RouteTableProviderV6EventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Creates a new route table. If the client end of the `provider` is
    /// closed, the route table is removed (unless detached).
    pub fn r#new_route_table(
        &self,
        mut provider: fdomain_client::fidl::ServerEnd<RouteTableV6Marker>,
        mut options: &RouteTableOptionsV6,
    ) -> Result<(), fidl::Error> {
        RouteTableProviderV6ProxyInterface::r#new_route_table(self, provider, options)
    }

    /// Gets the interface-local route table for this interface.
    ///
    /// + request credential of the interface to get local route table.
    /// - response client end of the `RouteTableV6` protocol if successfully.
    ///
    /// This table is only removed after the interface is removed AND all
    /// outstanding `RouteTableV6` channels are closed.
    ///
    /// Calling detach on the route table is a no-op.
    pub fn r#get_interface_local_table(
        &self,
        mut credential: fdomain_fuchsia_net_resources::ProofOfInterfaceAuthorization,
    ) -> fidl::client::QueryResponseFut<
        RouteTableProviderV6GetInterfaceLocalTableResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        RouteTableProviderV6ProxyInterface::r#get_interface_local_table(self, credential)
    }
}

impl RouteTableProviderV6ProxyInterface for RouteTableProviderV6Proxy {
    fn r#new_route_table(
        &self,
        mut provider: fdomain_client::fidl::ServerEnd<RouteTableV6Marker>,
        mut options: &RouteTableOptionsV6,
    ) -> Result<(), fidl::Error> {
        self.client.send::<RouteTableProviderV6NewRouteTableRequest>(
            (provider, options),
            0x152b67b397a31ca,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type GetInterfaceLocalTableResponseFut = fidl::client::QueryResponseFut<
        RouteTableProviderV6GetInterfaceLocalTableResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_interface_local_table(
        &self,
        mut credential: fdomain_fuchsia_net_resources::ProofOfInterfaceAuthorization,
    ) -> Self::GetInterfaceLocalTableResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RouteTableProviderV6GetInterfaceLocalTableResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    RouteTableProviderV6GetInterfaceLocalTableResponse,
                    GetInterfaceLocalTableError,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                0x6f82c1d63c3081f5,
            >(_buf?)?;
            Ok(_response.map(|x| x.route_table))
        }
        self.client.send_query_and_decode::<
            RouteTableProviderV6GetInterfaceLocalTableRequest,
            RouteTableProviderV6GetInterfaceLocalTableResult,
        >(
            (&mut credential,),
            0x6f82c1d63c3081f5,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

pub struct RouteTableProviderV6EventStream {
    event_receiver: fidl::client::EventReceiver<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.net.routes.admin/RouteTableProviderV6.
pub struct RouteTableProviderV6RequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fdomain_client::fidl::RequestStream for RouteTableProviderV6RequestStream {
    type Protocol = RouteTableProviderV6Marker;
    type ControlHandle = RouteTableProviderV6ControlHandle;

    fn from_channel(channel: fdomain_client::Channel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        RouteTableProviderV6ControlHandle { inner: self.inner.clone() }
    }

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

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

impl futures::Stream for RouteTableProviderV6RequestStream {
    type Item = Result<RouteTableProviderV6Request, 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 RouteTableProviderV6RequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |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(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(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 {
                0x152b67b397a31ca => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(RouteTableProviderV6NewRouteTableRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<RouteTableProviderV6NewRouteTableRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = RouteTableProviderV6ControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(RouteTableProviderV6Request::NewRouteTable {provider: req.provider,
options: req.options,

                        control_handle,
                    })
                }
                0x6f82c1d63c3081f5 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(RouteTableProviderV6GetInterfaceLocalTableRequest, fdomain_client::fidl::FDomainResourceDialect);
                    fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<RouteTableProviderV6GetInterfaceLocalTableRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = RouteTableProviderV6ControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(RouteTableProviderV6Request::GetInterfaceLocalTable {credential: req.credential,

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

/// This protocol allows the client to create route tables.
#[derive(Debug)]
pub enum RouteTableProviderV6Request {
    /// Creates a new route table. If the client end of the `provider` is
    /// closed, the route table is removed (unless detached).
    NewRouteTable {
        provider: fdomain_client::fidl::ServerEnd<RouteTableV6Marker>,
        options: RouteTableOptionsV6,
        control_handle: RouteTableProviderV6ControlHandle,
    },
    /// Gets the interface-local route table for this interface.
    ///
    /// + request credential of the interface to get local route table.
    /// - response client end of the `RouteTableV6` protocol if successfully.
    ///
    /// This table is only removed after the interface is removed AND all
    /// outstanding `RouteTableV6` channels are closed.
    ///
    /// Calling detach on the route table is a no-op.
    GetInterfaceLocalTable {
        credential: fdomain_fuchsia_net_resources::ProofOfInterfaceAuthorization,
        responder: RouteTableProviderV6GetInterfaceLocalTableResponder,
    },
}

impl RouteTableProviderV6Request {
    #[allow(irrefutable_let_patterns)]
    pub fn into_new_route_table(
        self,
    ) -> Option<(
        fdomain_client::fidl::ServerEnd<RouteTableV6Marker>,
        RouteTableOptionsV6,
        RouteTableProviderV6ControlHandle,
    )> {
        if let RouteTableProviderV6Request::NewRouteTable { provider, options, control_handle } =
            self
        {
            Some((provider, options, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_interface_local_table(
        self,
    ) -> Option<(
        fdomain_fuchsia_net_resources::ProofOfInterfaceAuthorization,
        RouteTableProviderV6GetInterfaceLocalTableResponder,
    )> {
        if let RouteTableProviderV6Request::GetInterfaceLocalTable { credential, responder } = self
        {
            Some((credential, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            RouteTableProviderV6Request::NewRouteTable { .. } => "new_route_table",
            RouteTableProviderV6Request::GetInterfaceLocalTable { .. } => {
                "get_interface_local_table"
            }
        }
    }
}

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

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

impl fdomain_client::fidl::ControlHandle for RouteTableProviderV6ControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

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

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fdomain_client::OnFDomainSignals {
        self.inner.channel().on_closed()
    }
}

impl RouteTableProviderV6ControlHandle {}

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

/// Set the the channel to be shutdown (see [`RouteTableProviderV6ControlHandle::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 RouteTableProviderV6GetInterfaceLocalTableResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for RouteTableProviderV6GetInterfaceLocalTableResponder {
    type ControlHandle = RouteTableProviderV6ControlHandle;

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

    fn send_raw(
        &self,
        mut result: Result<
            fdomain_client::fidl::ClientEnd<RouteTableV6Marker>,
            GetInterfaceLocalTableError,
        >,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            RouteTableProviderV6GetInterfaceLocalTableResponse,
            GetInterfaceLocalTableError,
        >>(
            result.map(|route_table| (route_table,)),
            self.tx_id,
            0x6f82c1d63c3081f5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fdomain_client::fidl::ProtocolMarker for RouteTableV4Marker {
    type Proxy = RouteTableV4Proxy;
    type RequestStream = RouteTableV4RequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.net.routes.admin.RouteTableV4";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for RouteTableV4Marker {}

pub trait RouteTableV4ProxyInterface: Send + Sync {
    type GetTableIdResponseFut: std::future::Future<Output = Result<u32, fidl::Error>> + Send;
    fn r#get_table_id(&self) -> Self::GetTableIdResponseFut;
    fn r#detach(&self) -> Result<(), fidl::Error>;
    type RemoveResponseFut: std::future::Future<Output = Result<BaseRouteTableRemoveResult, fidl::Error>>
        + Send;
    fn r#remove(&self) -> Self::RemoveResponseFut;
    type GetAuthorizationForRouteTableResponseFut: std::future::Future<Output = Result<GrantForRouteTableAuthorization, fidl::Error>>
        + Send;
    fn r#get_authorization_for_route_table(&self)
    -> Self::GetAuthorizationForRouteTableResponseFut;
    fn r#new_route_set(
        &self,
        route_set: fdomain_client::fidl::ServerEnd<RouteSetV4Marker>,
    ) -> Result<(), fidl::Error>;
}

#[derive(Debug, Clone)]
pub struct RouteTableV4Proxy {
    client: fidl::client::Client<fdomain_client::fidl::FDomainResourceDialect>,
}

impl fdomain_client::fidl::Proxy for RouteTableV4Proxy {
    type Protocol = RouteTableV4Marker;

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

    fn into_channel(self) -> Result<fdomain_client::Channel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

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

impl RouteTableV4Proxy {
    /// Create a new Proxy for fuchsia.net.routes.admin/RouteTableV4.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name =
            <RouteTableV4Marker as fdomain_client::fidl::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) -> RouteTableV4EventStream {
        RouteTableV4EventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Gets the table ID for this table.
    pub fn r#get_table_id(
        &self,
    ) -> fidl::client::QueryResponseFut<u32, fdomain_client::fidl::FDomainResourceDialect> {
        RouteTableV4ProxyInterface::r#get_table_id(self)
    }

    /// Detaches the lifetime of the route table from the lifetime of the
    /// client end of the channel.
    ///
    /// After this method is called, the route table will not be removed
    /// if the client end is closed. It's a no-op if called on the main table.
    pub fn r#detach(&self) -> Result<(), fidl::Error> {
        RouteTableV4ProxyInterface::r#detach(self)
    }

    /// Removes the route table explicitly.
    ///
    /// This method cannot be called on the main table or an interface-local
    /// table, an error will be returned if called. The server will close the
    /// channel after this method successfully returns.
    pub fn r#remove(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseRouteTableRemoveResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        RouteTableV4ProxyInterface::r#remove(self)
    }

    /// Gets an authentication credential for this table.
    ///
    /// The credential contains a [`zx::handle::EVENT`], whose duplicate is
    /// held by the server. This credential can be passed into
    /// `fuchsia.net.routes.admin` API calls to prove ownership of this route
    /// table. The `EVENT` is stable throughout the lifetime of the route table.
    /// Clients may duplicate this `EVENT` to make multiple API calls, or
    /// transfer the `EVENT` to other clients.
    ///
    /// - response `credential` the authorization credential for this table.
    pub fn r#get_authorization_for_route_table(
        &self,
    ) -> fidl::client::QueryResponseFut<
        GrantForRouteTableAuthorization,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        RouteTableV4ProxyInterface::r#get_authorization_for_route_table(self)
    }

    /// Creates an empty route set.
    ///
    /// + request `route_set` grants access to the [`RouteSetV4`] protocol.
    pub fn r#new_route_set(
        &self,
        mut route_set: fdomain_client::fidl::ServerEnd<RouteSetV4Marker>,
    ) -> Result<(), fidl::Error> {
        RouteTableV4ProxyInterface::r#new_route_set(self, route_set)
    }
}

impl RouteTableV4ProxyInterface for RouteTableV4Proxy {
    type GetTableIdResponseFut =
        fidl::client::QueryResponseFut<u32, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#get_table_id(&self) -> Self::GetTableIdResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<u32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                BaseRouteTableGetTableIdResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x7eab30c55edbfc15,
            >(_buf?)?;
            Ok(_response.table_id)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, u32>(
            (),
            0x7eab30c55edbfc15,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

    type RemoveResponseFut = fidl::client::QueryResponseFut<
        BaseRouteTableRemoveResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#remove(&self) -> Self::RemoveResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseRouteTableRemoveResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, BaseRouteTableRemoveError>,
                fdomain_client::fidl::FDomainResourceDialect,
                0xc42e58a5fc79426,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseRouteTableRemoveResult>(
                (),
                0xc42e58a5fc79426,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetAuthorizationForRouteTableResponseFut = fidl::client::QueryResponseFut<
        GrantForRouteTableAuthorization,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_authorization_for_route_table(
        &self,
    ) -> Self::GetAuthorizationForRouteTableResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<GrantForRouteTableAuthorization, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                BaseRouteTableGetAuthorizationForRouteTableResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x56a48c921ff3b6eb,
            >(_buf?)?;
            Ok(_response.credential)
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, GrantForRouteTableAuthorization>(
                (),
                0x56a48c921ff3b6eb,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    fn r#new_route_set(
        &self,
        mut route_set: fdomain_client::fidl::ServerEnd<RouteSetV4Marker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<RouteTableV4NewRouteSetRequest>(
            (route_set,),
            0x6aeb6d05698abedb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

pub struct RouteTableV4EventStream {
    event_receiver: fidl::client::EventReceiver<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.net.routes.admin/RouteTableV4.
pub struct RouteTableV4RequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fdomain_client::fidl::RequestStream for RouteTableV4RequestStream {
    type Protocol = RouteTableV4Marker;
    type ControlHandle = RouteTableV4ControlHandle;

    fn from_channel(channel: fdomain_client::Channel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        RouteTableV4ControlHandle { inner: self.inner.clone() }
    }

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

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

impl futures::Stream for RouteTableV4RequestStream {
    type Item = Result<RouteTableV4Request, 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 RouteTableV4RequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |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(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(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 {
                    0x7eab30c55edbfc15 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            RouteTableV4ControlHandle { inner: this.inner.clone() };
                        Ok(RouteTableV4Request::GetTableId {
                            responder: RouteTableV4GetTableIdResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2853ab157285b384 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            RouteTableV4ControlHandle { inner: this.inner.clone() };
                        Ok(RouteTableV4Request::Detach { control_handle })
                    }
                    0xc42e58a5fc79426 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            RouteTableV4ControlHandle { inner: this.inner.clone() };
                        Ok(RouteTableV4Request::Remove {
                            responder: RouteTableV4RemoveResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x56a48c921ff3b6eb => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            RouteTableV4ControlHandle { inner: this.inner.clone() };
                        Ok(RouteTableV4Request::GetAuthorizationForRouteTable {
                            responder: RouteTableV4GetAuthorizationForRouteTableResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6aeb6d05698abedb => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            RouteTableV4NewRouteSetRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<RouteTableV4NewRouteSetRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            RouteTableV4ControlHandle { inner: this.inner.clone() };
                        Ok(RouteTableV4Request::NewRouteSet {
                            route_set: req.route_set,

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

/// Vends isolated administrative access to the system's IPv4 routing table.
///
/// A main route table is accessible through the discoverable [`RouteTableV4`]
/// protocol. Other tables can be installed using the `NewRouteTable` method
/// on [`RouteTableProviderV4`]. The [`RouteTableV4`] also encodes the lifetime
/// of the underlying route table, dropping the client end of the protocol
/// causes the underlying route table to be removed unless it is detached. The
/// main table is detached by default.
#[derive(Debug)]
pub enum RouteTableV4Request {
    /// Gets the table ID for this table.
    GetTableId { responder: RouteTableV4GetTableIdResponder },
    /// Detaches the lifetime of the route table from the lifetime of the
    /// client end of the channel.
    ///
    /// After this method is called, the route table will not be removed
    /// if the client end is closed. It's a no-op if called on the main table.
    Detach { control_handle: RouteTableV4ControlHandle },
    /// Removes the route table explicitly.
    ///
    /// This method cannot be called on the main table or an interface-local
    /// table, an error will be returned if called. The server will close the
    /// channel after this method successfully returns.
    Remove { responder: RouteTableV4RemoveResponder },
    /// Gets an authentication credential for this table.
    ///
    /// The credential contains a [`zx::handle::EVENT`], whose duplicate is
    /// held by the server. This credential can be passed into
    /// `fuchsia.net.routes.admin` API calls to prove ownership of this route
    /// table. The `EVENT` is stable throughout the lifetime of the route table.
    /// Clients may duplicate this `EVENT` to make multiple API calls, or
    /// transfer the `EVENT` to other clients.
    ///
    /// - response `credential` the authorization credential for this table.
    GetAuthorizationForRouteTable { responder: RouteTableV4GetAuthorizationForRouteTableResponder },
    /// Creates an empty route set.
    ///
    /// + request `route_set` grants access to the [`RouteSetV4`] protocol.
    NewRouteSet {
        route_set: fdomain_client::fidl::ServerEnd<RouteSetV4Marker>,
        control_handle: RouteTableV4ControlHandle,
    },
}

impl RouteTableV4Request {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_table_id(self) -> Option<(RouteTableV4GetTableIdResponder)> {
        if let RouteTableV4Request::GetTableId { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_detach(self) -> Option<(RouteTableV4ControlHandle)> {
        if let RouteTableV4Request::Detach { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_remove(self) -> Option<(RouteTableV4RemoveResponder)> {
        if let RouteTableV4Request::Remove { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_authorization_for_route_table(
        self,
    ) -> Option<(RouteTableV4GetAuthorizationForRouteTableResponder)> {
        if let RouteTableV4Request::GetAuthorizationForRouteTable { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_new_route_set(
        self,
    ) -> Option<(fdomain_client::fidl::ServerEnd<RouteSetV4Marker>, RouteTableV4ControlHandle)>
    {
        if let RouteTableV4Request::NewRouteSet { route_set, control_handle } = self {
            Some((route_set, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            RouteTableV4Request::GetTableId { .. } => "get_table_id",
            RouteTableV4Request::Detach { .. } => "detach",
            RouteTableV4Request::Remove { .. } => "remove",
            RouteTableV4Request::GetAuthorizationForRouteTable { .. } => {
                "get_authorization_for_route_table"
            }
            RouteTableV4Request::NewRouteSet { .. } => "new_route_set",
        }
    }
}

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

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

impl fdomain_client::fidl::ControlHandle for RouteTableV4ControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

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

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fdomain_client::OnFDomainSignals {
        self.inner.channel().on_closed()
    }
}

impl RouteTableV4ControlHandle {}

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

/// Set the the channel to be shutdown (see [`RouteTableV4ControlHandle::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 RouteTableV4GetTableIdResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for RouteTableV4GetTableIdResponder {
    type ControlHandle = RouteTableV4ControlHandle;

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

    fn send_raw(&self, mut table_id: u32) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<BaseRouteTableGetTableIdResponse>(
            (table_id,),
            self.tx_id,
            0x7eab30c55edbfc15,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`RouteTableV4ControlHandle::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 RouteTableV4RemoveResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for RouteTableV4RemoveResponder {
    type ControlHandle = RouteTableV4ControlHandle;

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

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

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

/// Set the the channel to be shutdown (see [`RouteTableV4ControlHandle::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 RouteTableV4GetAuthorizationForRouteTableResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for RouteTableV4GetAuthorizationForRouteTableResponder {
    type ControlHandle = RouteTableV4ControlHandle;

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

    fn send_raw(&self, mut credential: GrantForRouteTableAuthorization) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<BaseRouteTableGetAuthorizationForRouteTableResponse>(
            (&mut credential,),
            self.tx_id,
            0x56a48c921ff3b6eb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fdomain_client::fidl::ProtocolMarker for RouteTableV6Marker {
    type Proxy = RouteTableV6Proxy;
    type RequestStream = RouteTableV6RequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.net.routes.admin.RouteTableV6";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for RouteTableV6Marker {}

pub trait RouteTableV6ProxyInterface: Send + Sync {
    type GetTableIdResponseFut: std::future::Future<Output = Result<u32, fidl::Error>> + Send;
    fn r#get_table_id(&self) -> Self::GetTableIdResponseFut;
    fn r#detach(&self) -> Result<(), fidl::Error>;
    type RemoveResponseFut: std::future::Future<Output = Result<BaseRouteTableRemoveResult, fidl::Error>>
        + Send;
    fn r#remove(&self) -> Self::RemoveResponseFut;
    type GetAuthorizationForRouteTableResponseFut: std::future::Future<Output = Result<GrantForRouteTableAuthorization, fidl::Error>>
        + Send;
    fn r#get_authorization_for_route_table(&self)
    -> Self::GetAuthorizationForRouteTableResponseFut;
    fn r#new_route_set(
        &self,
        route_set: fdomain_client::fidl::ServerEnd<RouteSetV6Marker>,
    ) -> Result<(), fidl::Error>;
}

#[derive(Debug, Clone)]
pub struct RouteTableV6Proxy {
    client: fidl::client::Client<fdomain_client::fidl::FDomainResourceDialect>,
}

impl fdomain_client::fidl::Proxy for RouteTableV6Proxy {
    type Protocol = RouteTableV6Marker;

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

    fn into_channel(self) -> Result<fdomain_client::Channel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

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

impl RouteTableV6Proxy {
    /// Create a new Proxy for fuchsia.net.routes.admin/RouteTableV6.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name =
            <RouteTableV6Marker as fdomain_client::fidl::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) -> RouteTableV6EventStream {
        RouteTableV6EventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Gets the table ID for this table.
    pub fn r#get_table_id(
        &self,
    ) -> fidl::client::QueryResponseFut<u32, fdomain_client::fidl::FDomainResourceDialect> {
        RouteTableV6ProxyInterface::r#get_table_id(self)
    }

    /// Detaches the lifetime of the route table from the lifetime of the
    /// client end of the channel.
    ///
    /// After this method is called, the route table will not be removed
    /// if the client end is closed. It's a no-op if called on the main table.
    pub fn r#detach(&self) -> Result<(), fidl::Error> {
        RouteTableV6ProxyInterface::r#detach(self)
    }

    /// Removes the route table explicitly.
    ///
    /// This method cannot be called on the main table or an interface-local
    /// table, an error will be returned if called. The server will close the
    /// channel after this method successfully returns.
    pub fn r#remove(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseRouteTableRemoveResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        RouteTableV6ProxyInterface::r#remove(self)
    }

    /// Gets an authentication credential for this table.
    ///
    /// The credential contains a [`zx::handle::EVENT`], whose duplicate is
    /// held by the server. This credential can be passed into
    /// `fuchsia.net.routes.admin` API calls to prove ownership of this route
    /// table. The `EVENT` is stable throughout the lifetime of the route table.
    /// Clients may duplicate this `EVENT` to make multiple API calls, or
    /// transfer the `EVENT` to other clients.
    ///
    /// - response `credential` the authorization credential for this table.
    pub fn r#get_authorization_for_route_table(
        &self,
    ) -> fidl::client::QueryResponseFut<
        GrantForRouteTableAuthorization,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        RouteTableV6ProxyInterface::r#get_authorization_for_route_table(self)
    }

    /// Creates an empty route set.
    ///
    /// + request `route_set` grants access to the [`RouteSetV6`] protocol.
    pub fn r#new_route_set(
        &self,
        mut route_set: fdomain_client::fidl::ServerEnd<RouteSetV6Marker>,
    ) -> Result<(), fidl::Error> {
        RouteTableV6ProxyInterface::r#new_route_set(self, route_set)
    }
}

impl RouteTableV6ProxyInterface for RouteTableV6Proxy {
    type GetTableIdResponseFut =
        fidl::client::QueryResponseFut<u32, fdomain_client::fidl::FDomainResourceDialect>;
    fn r#get_table_id(&self) -> Self::GetTableIdResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<u32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                BaseRouteTableGetTableIdResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x7eab30c55edbfc15,
            >(_buf?)?;
            Ok(_response.table_id)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, u32>(
            (),
            0x7eab30c55edbfc15,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

    type RemoveResponseFut = fidl::client::QueryResponseFut<
        BaseRouteTableRemoveResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#remove(&self) -> Self::RemoveResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseRouteTableRemoveResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, BaseRouteTableRemoveError>,
                fdomain_client::fidl::FDomainResourceDialect,
                0xc42e58a5fc79426,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseRouteTableRemoveResult>(
                (),
                0xc42e58a5fc79426,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetAuthorizationForRouteTableResponseFut = fidl::client::QueryResponseFut<
        GrantForRouteTableAuthorization,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#get_authorization_for_route_table(
        &self,
    ) -> Self::GetAuthorizationForRouteTableResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<GrantForRouteTableAuthorization, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                BaseRouteTableGetAuthorizationForRouteTableResponse,
                fdomain_client::fidl::FDomainResourceDialect,
                0x56a48c921ff3b6eb,
            >(_buf?)?;
            Ok(_response.credential)
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, GrantForRouteTableAuthorization>(
                (),
                0x56a48c921ff3b6eb,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    fn r#new_route_set(
        &self,
        mut route_set: fdomain_client::fidl::ServerEnd<RouteSetV6Marker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<RouteTableV6NewRouteSetRequest>(
            (route_set,),
            0x479aeaf9ad470141,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

pub struct RouteTableV6EventStream {
    event_receiver: fidl::client::EventReceiver<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.net.routes.admin/RouteTableV6.
pub struct RouteTableV6RequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fdomain_client::fidl::RequestStream for RouteTableV6RequestStream {
    type Protocol = RouteTableV6Marker;
    type ControlHandle = RouteTableV6ControlHandle;

    fn from_channel(channel: fdomain_client::Channel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        RouteTableV6ControlHandle { inner: self.inner.clone() }
    }

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

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

impl futures::Stream for RouteTableV6RequestStream {
    type Item = Result<RouteTableV6Request, 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 RouteTableV6RequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |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(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(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 {
                    0x7eab30c55edbfc15 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            RouteTableV6ControlHandle { inner: this.inner.clone() };
                        Ok(RouteTableV6Request::GetTableId {
                            responder: RouteTableV6GetTableIdResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2853ab157285b384 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            RouteTableV6ControlHandle { inner: this.inner.clone() };
                        Ok(RouteTableV6Request::Detach { control_handle })
                    }
                    0xc42e58a5fc79426 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            RouteTableV6ControlHandle { inner: this.inner.clone() };
                        Ok(RouteTableV6Request::Remove {
                            responder: RouteTableV6RemoveResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x56a48c921ff3b6eb => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            RouteTableV6ControlHandle { inner: this.inner.clone() };
                        Ok(RouteTableV6Request::GetAuthorizationForRouteTable {
                            responder: RouteTableV6GetAuthorizationForRouteTableResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x479aeaf9ad470141 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            RouteTableV6NewRouteSetRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<RouteTableV6NewRouteSetRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            RouteTableV6ControlHandle { inner: this.inner.clone() };
                        Ok(RouteTableV6Request::NewRouteSet {
                            route_set: req.route_set,

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

/// Vends isolated administrative access to the system's IPv6 routing table.
///
/// A main route table is accessible through the discoverable [`RouteTableV6`]
/// protocol. Other tables can be installed using the `NewRouteTable` method
/// on [`RouteTableProviderV6`]. The [`RouteTableV6`] also encodes the lifetime
/// of the underlying route table, dropping the client end of the protocol
/// causes the underlying route table to be removed unless it is detached. The
/// main table is detached by default.
#[derive(Debug)]
pub enum RouteTableV6Request {
    /// Gets the table ID for this table.
    GetTableId { responder: RouteTableV6GetTableIdResponder },
    /// Detaches the lifetime of the route table from the lifetime of the
    /// client end of the channel.
    ///
    /// After this method is called, the route table will not be removed
    /// if the client end is closed. It's a no-op if called on the main table.
    Detach { control_handle: RouteTableV6ControlHandle },
    /// Removes the route table explicitly.
    ///
    /// This method cannot be called on the main table or an interface-local
    /// table, an error will be returned if called. The server will close the
    /// channel after this method successfully returns.
    Remove { responder: RouteTableV6RemoveResponder },
    /// Gets an authentication credential for this table.
    ///
    /// The credential contains a [`zx::handle::EVENT`], whose duplicate is
    /// held by the server. This credential can be passed into
    /// `fuchsia.net.routes.admin` API calls to prove ownership of this route
    /// table. The `EVENT` is stable throughout the lifetime of the route table.
    /// Clients may duplicate this `EVENT` to make multiple API calls, or
    /// transfer the `EVENT` to other clients.
    ///
    /// - response `credential` the authorization credential for this table.
    GetAuthorizationForRouteTable { responder: RouteTableV6GetAuthorizationForRouteTableResponder },
    /// Creates an empty route set.
    ///
    /// + request `route_set` grants access to the [`RouteSetV6`] protocol.
    NewRouteSet {
        route_set: fdomain_client::fidl::ServerEnd<RouteSetV6Marker>,
        control_handle: RouteTableV6ControlHandle,
    },
}

impl RouteTableV6Request {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_table_id(self) -> Option<(RouteTableV6GetTableIdResponder)> {
        if let RouteTableV6Request::GetTableId { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_detach(self) -> Option<(RouteTableV6ControlHandle)> {
        if let RouteTableV6Request::Detach { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_remove(self) -> Option<(RouteTableV6RemoveResponder)> {
        if let RouteTableV6Request::Remove { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_authorization_for_route_table(
        self,
    ) -> Option<(RouteTableV6GetAuthorizationForRouteTableResponder)> {
        if let RouteTableV6Request::GetAuthorizationForRouteTable { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_new_route_set(
        self,
    ) -> Option<(fdomain_client::fidl::ServerEnd<RouteSetV6Marker>, RouteTableV6ControlHandle)>
    {
        if let RouteTableV6Request::NewRouteSet { route_set, control_handle } = self {
            Some((route_set, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            RouteTableV6Request::GetTableId { .. } => "get_table_id",
            RouteTableV6Request::Detach { .. } => "detach",
            RouteTableV6Request::Remove { .. } => "remove",
            RouteTableV6Request::GetAuthorizationForRouteTable { .. } => {
                "get_authorization_for_route_table"
            }
            RouteTableV6Request::NewRouteSet { .. } => "new_route_set",
        }
    }
}

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

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

impl fdomain_client::fidl::ControlHandle for RouteTableV6ControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

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

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fdomain_client::OnFDomainSignals {
        self.inner.channel().on_closed()
    }
}

impl RouteTableV6ControlHandle {}

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

/// Set the the channel to be shutdown (see [`RouteTableV6ControlHandle::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 RouteTableV6GetTableIdResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for RouteTableV6GetTableIdResponder {
    type ControlHandle = RouteTableV6ControlHandle;

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

    fn send_raw(&self, mut table_id: u32) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<BaseRouteTableGetTableIdResponse>(
            (table_id,),
            self.tx_id,
            0x7eab30c55edbfc15,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`RouteTableV6ControlHandle::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 RouteTableV6RemoveResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for RouteTableV6RemoveResponder {
    type ControlHandle = RouteTableV6ControlHandle;

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

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

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

/// Set the the channel to be shutdown (see [`RouteTableV6ControlHandle::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 RouteTableV6GetAuthorizationForRouteTableResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for RouteTableV6GetAuthorizationForRouteTableResponder {
    type ControlHandle = RouteTableV6ControlHandle;

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

    fn send_raw(&self, mut credential: GrantForRouteTableAuthorization) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<BaseRouteTableGetAuthorizationForRouteTableResponse>(
            (&mut credential,),
            self.tx_id,
            0x56a48c921ff3b6eb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fdomain_client::fidl::ProtocolMarker for RuleSetV4Marker {
    type Proxy = RuleSetV4Proxy;
    type RequestStream = RuleSetV4RequestStream;

    const DEBUG_NAME: &'static str = "(anonymous) RuleSetV4";
}
pub type RuleSetV4AddRuleResult = Result<(), RuleSetError>;

pub trait RuleSetV4ProxyInterface: Send + Sync {
    type AuthenticateForRouteTableResponseFut: std::future::Future<
            Output = Result<BaseRuleSetAuthenticateForRouteTableResult, fidl::Error>,
        > + Send;
    fn r#authenticate_for_route_table(
        &self,
        table: u32,
        token: fdomain_client::Event,
    ) -> Self::AuthenticateForRouteTableResponseFut;
    type RemoveRuleResponseFut: std::future::Future<Output = Result<BaseRuleSetRemoveRuleResult, fidl::Error>>
        + Send;
    fn r#remove_rule(&self, index: u32) -> Self::RemoveRuleResponseFut;
    fn r#close(&self) -> Result<(), fidl::Error>;
    type AddRuleResponseFut: std::future::Future<Output = Result<RuleSetV4AddRuleResult, fidl::Error>>
        + Send;
    fn r#add_rule(
        &self,
        index: u32,
        matcher: &fdomain_fuchsia_net_routes::RuleMatcherV4,
        action: &fdomain_fuchsia_net_routes::RuleAction,
    ) -> Self::AddRuleResponseFut;
}

#[derive(Debug, Clone)]
pub struct RuleSetV4Proxy {
    client: fidl::client::Client<fdomain_client::fidl::FDomainResourceDialect>,
}

impl fdomain_client::fidl::Proxy for RuleSetV4Proxy {
    type Protocol = RuleSetV4Marker;

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

    fn into_channel(self) -> Result<fdomain_client::Channel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

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

impl RuleSetV4Proxy {
    /// Create a new Proxy for fuchsia.net.routes.admin/RuleSetV4.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name = <RuleSetV4Marker as fdomain_client::fidl::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) -> RuleSetV4EventStream {
        RuleSetV4EventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Authenticates for a route table that will be used in an action.
    pub fn r#authenticate_for_route_table(
        &self,
        mut table: u32,
        mut token: fdomain_client::Event,
    ) -> fidl::client::QueryResponseFut<
        BaseRuleSetAuthenticateForRouteTableResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        RuleSetV4ProxyInterface::r#authenticate_for_route_table(self, table, token)
    }

    /// Removes a rule from this rule set.
    ///
    /// If the client tries to remove from an index that does not have a rule,
    /// the error `RULE_DOES_NOT_EXIST` will be returned.
    ///
    /// + request `index` the index of the rule.
    pub fn r#remove_rule(
        &self,
        mut index: u32,
    ) -> fidl::client::QueryResponseFut<
        BaseRuleSetRemoveRuleResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        RuleSetV4ProxyInterface::r#remove_rule(self, index)
    }

    /// Removes all rules in the rule set and the underlying channel will be
    /// closed after the rules are removed.
    ///
    /// This method provides a way for synchronous closure.
    pub fn r#close(&self) -> Result<(), fidl::Error> {
        RuleSetV4ProxyInterface::r#close(self)
    }

    /// Adds a rule to this rule set.
    ///
    /// If there is already a rule at the provided `index`, `RULE_ALREADY_EXISTS`
    /// is returned.
    ///
    /// + request `index` where to insert the rule.
    /// + request `matcher` the matcher of the rule.
    /// + request `action` action of the rule.
    pub fn r#add_rule(
        &self,
        mut index: u32,
        mut matcher: &fdomain_fuchsia_net_routes::RuleMatcherV4,
        mut action: &fdomain_fuchsia_net_routes::RuleAction,
    ) -> fidl::client::QueryResponseFut<
        RuleSetV4AddRuleResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        RuleSetV4ProxyInterface::r#add_rule(self, index, matcher, action)
    }
}

impl RuleSetV4ProxyInterface for RuleSetV4Proxy {
    type AuthenticateForRouteTableResponseFut = fidl::client::QueryResponseFut<
        BaseRuleSetAuthenticateForRouteTableResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#authenticate_for_route_table(
        &self,
        mut table: u32,
        mut token: fdomain_client::Event,
    ) -> Self::AuthenticateForRouteTableResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseRuleSetAuthenticateForRouteTableResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    AuthenticateForRouteTableError,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                0x6fd845360ed9bc8f,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            ProofOfRouteTableAuthorization,
            BaseRuleSetAuthenticateForRouteTableResult,
        >(
            (table, token,),
            0x6fd845360ed9bc8f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type RemoveRuleResponseFut = fidl::client::QueryResponseFut<
        BaseRuleSetRemoveRuleResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#remove_rule(&self, mut index: u32) -> Self::RemoveRuleResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseRuleSetRemoveRuleResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, RuleSetError>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x2ae3d7e817cbff90,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BaseRuleSetRemoveRuleRequest, BaseRuleSetRemoveRuleResult>(
                (index,),
                0x2ae3d7e817cbff90,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

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

    type AddRuleResponseFut = fidl::client::QueryResponseFut<
        RuleSetV4AddRuleResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#add_rule(
        &self,
        mut index: u32,
        mut matcher: &fdomain_fuchsia_net_routes::RuleMatcherV4,
        mut action: &fdomain_fuchsia_net_routes::RuleAction,
    ) -> Self::AddRuleResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RuleSetV4AddRuleResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, RuleSetError>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x7f68325de94e80,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<RuleSetV4AddRuleRequest, RuleSetV4AddRuleResult>(
            (index, matcher, action),
            0x7f68325de94e80,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

pub struct RuleSetV4EventStream {
    event_receiver: fidl::client::EventReceiver<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.net.routes.admin/RuleSetV4.
pub struct RuleSetV4RequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fdomain_client::fidl::RequestStream for RuleSetV4RequestStream {
    type Protocol = RuleSetV4Marker;
    type ControlHandle = RuleSetV4ControlHandle;

    fn from_channel(channel: fdomain_client::Channel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        RuleSetV4ControlHandle { inner: self.inner.clone() }
    }

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

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

impl futures::Stream for RuleSetV4RequestStream {
    type Item = Result<RuleSetV4Request, 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 RuleSetV4RequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |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(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(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 {
                    0x6fd845360ed9bc8f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ProofOfRouteTableAuthorization,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<ProofOfRouteTableAuthorization>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RuleSetV4ControlHandle { inner: this.inner.clone() };
                        Ok(RuleSetV4Request::AuthenticateForRouteTable {
                            table: req.table,
                            token: req.token,

                            responder: RuleSetV4AuthenticateForRouteTableResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2ae3d7e817cbff90 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseRuleSetRemoveRuleRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<BaseRuleSetRemoveRuleRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RuleSetV4ControlHandle { inner: this.inner.clone() };
                        Ok(RuleSetV4Request::RemoveRule {
                            index: req.index,

                            responder: RuleSetV4RemoveRuleResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x457e1753672d4073 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RuleSetV4ControlHandle { inner: this.inner.clone() };
                        Ok(RuleSetV4Request::Close { control_handle })
                    }
                    0x7f68325de94e80 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RuleSetV4AddRuleRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<RuleSetV4AddRuleRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RuleSetV4ControlHandle { inner: this.inner.clone() };
                        Ok(RuleSetV4Request::AddRule {
                            index: req.index,
                            matcher: req.matcher,
                            action: req.action,

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

/// Provides mutable access over a set of the system's IPv4 route rules.
///
/// A `RuleSet` has a priority and a rule has an index. A global order among the
/// rules is determined first by the priority of the `RuleSet` the rule belongs
/// to, and then the index of the rule inside the `RuleSet`.
///
/// This protocol encodes the lifetime of the rule set. Closing the client end
/// removes the rule set, and all the rules that are owned by the rule set.
#[derive(Debug)]
pub enum RuleSetV4Request {
    /// Authenticates for a route table that will be used in an action.
    AuthenticateForRouteTable {
        table: u32,
        token: fdomain_client::Event,
        responder: RuleSetV4AuthenticateForRouteTableResponder,
    },
    /// Removes a rule from this rule set.
    ///
    /// If the client tries to remove from an index that does not have a rule,
    /// the error `RULE_DOES_NOT_EXIST` will be returned.
    ///
    /// + request `index` the index of the rule.
    RemoveRule { index: u32, responder: RuleSetV4RemoveRuleResponder },
    /// Removes all rules in the rule set and the underlying channel will be
    /// closed after the rules are removed.
    ///
    /// This method provides a way for synchronous closure.
    Close { control_handle: RuleSetV4ControlHandle },
    /// Adds a rule to this rule set.
    ///
    /// If there is already a rule at the provided `index`, `RULE_ALREADY_EXISTS`
    /// is returned.
    ///
    /// + request `index` where to insert the rule.
    /// + request `matcher` the matcher of the rule.
    /// + request `action` action of the rule.
    AddRule {
        index: u32,
        matcher: fdomain_fuchsia_net_routes::RuleMatcherV4,
        action: fdomain_fuchsia_net_routes::RuleAction,
        responder: RuleSetV4AddRuleResponder,
    },
}

impl RuleSetV4Request {
    #[allow(irrefutable_let_patterns)]
    pub fn into_authenticate_for_route_table(
        self,
    ) -> Option<(u32, fdomain_client::Event, RuleSetV4AuthenticateForRouteTableResponder)> {
        if let RuleSetV4Request::AuthenticateForRouteTable { table, token, responder } = self {
            Some((table, token, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_remove_rule(self) -> Option<(u32, RuleSetV4RemoveRuleResponder)> {
        if let RuleSetV4Request::RemoveRule { index, responder } = self {
            Some((index, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_close(self) -> Option<(RuleSetV4ControlHandle)> {
        if let RuleSetV4Request::Close { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_rule(
        self,
    ) -> Option<(
        u32,
        fdomain_fuchsia_net_routes::RuleMatcherV4,
        fdomain_fuchsia_net_routes::RuleAction,
        RuleSetV4AddRuleResponder,
    )> {
        if let RuleSetV4Request::AddRule { index, matcher, action, responder } = self {
            Some((index, matcher, action, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            RuleSetV4Request::AuthenticateForRouteTable { .. } => "authenticate_for_route_table",
            RuleSetV4Request::RemoveRule { .. } => "remove_rule",
            RuleSetV4Request::Close { .. } => "close",
            RuleSetV4Request::AddRule { .. } => "add_rule",
        }
    }
}

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

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

impl fdomain_client::fidl::ControlHandle for RuleSetV4ControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

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

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fdomain_client::OnFDomainSignals {
        self.inner.channel().on_closed()
    }
}

impl RuleSetV4ControlHandle {}

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

/// Set the the channel to be shutdown (see [`RuleSetV4ControlHandle::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 RuleSetV4AuthenticateForRouteTableResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for RuleSetV4AuthenticateForRouteTableResponder {
    type ControlHandle = RuleSetV4ControlHandle;

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

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

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

/// Set the the channel to be shutdown (see [`RuleSetV4ControlHandle::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 RuleSetV4RemoveRuleResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for RuleSetV4RemoveRuleResponder {
    type ControlHandle = RuleSetV4ControlHandle;

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

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

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

/// Set the the channel to be shutdown (see [`RuleSetV4ControlHandle::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 RuleSetV4AddRuleResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for RuleSetV4AddRuleResponder {
    type ControlHandle = RuleSetV4ControlHandle;

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

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

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

impl fdomain_client::fidl::ProtocolMarker for RuleSetV6Marker {
    type Proxy = RuleSetV6Proxy;
    type RequestStream = RuleSetV6RequestStream;

    const DEBUG_NAME: &'static str = "(anonymous) RuleSetV6";
}
pub type RuleSetV6AddRuleResult = Result<(), RuleSetError>;

pub trait RuleSetV6ProxyInterface: Send + Sync {
    type AuthenticateForRouteTableResponseFut: std::future::Future<
            Output = Result<BaseRuleSetAuthenticateForRouteTableResult, fidl::Error>,
        > + Send;
    fn r#authenticate_for_route_table(
        &self,
        table: u32,
        token: fdomain_client::Event,
    ) -> Self::AuthenticateForRouteTableResponseFut;
    type RemoveRuleResponseFut: std::future::Future<Output = Result<BaseRuleSetRemoveRuleResult, fidl::Error>>
        + Send;
    fn r#remove_rule(&self, index: u32) -> Self::RemoveRuleResponseFut;
    fn r#close(&self) -> Result<(), fidl::Error>;
    type AddRuleResponseFut: std::future::Future<Output = Result<RuleSetV6AddRuleResult, fidl::Error>>
        + Send;
    fn r#add_rule(
        &self,
        index: u32,
        matcher: &fdomain_fuchsia_net_routes::RuleMatcherV6,
        action: &fdomain_fuchsia_net_routes::RuleAction,
    ) -> Self::AddRuleResponseFut;
}

#[derive(Debug, Clone)]
pub struct RuleSetV6Proxy {
    client: fidl::client::Client<fdomain_client::fidl::FDomainResourceDialect>,
}

impl fdomain_client::fidl::Proxy for RuleSetV6Proxy {
    type Protocol = RuleSetV6Marker;

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

    fn into_channel(self) -> Result<fdomain_client::Channel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

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

impl RuleSetV6Proxy {
    /// Create a new Proxy for fuchsia.net.routes.admin/RuleSetV6.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name = <RuleSetV6Marker as fdomain_client::fidl::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) -> RuleSetV6EventStream {
        RuleSetV6EventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Authenticates for a route table that will be used in an action.
    pub fn r#authenticate_for_route_table(
        &self,
        mut table: u32,
        mut token: fdomain_client::Event,
    ) -> fidl::client::QueryResponseFut<
        BaseRuleSetAuthenticateForRouteTableResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        RuleSetV6ProxyInterface::r#authenticate_for_route_table(self, table, token)
    }

    /// Removes a rule from this rule set.
    ///
    /// If the client tries to remove from an index that does not have a rule,
    /// the error `RULE_DOES_NOT_EXIST` will be returned.
    ///
    /// + request `index` the index of the rule.
    pub fn r#remove_rule(
        &self,
        mut index: u32,
    ) -> fidl::client::QueryResponseFut<
        BaseRuleSetRemoveRuleResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        RuleSetV6ProxyInterface::r#remove_rule(self, index)
    }

    /// Removes all rules in the rule set and the underlying channel will be
    /// closed after the rules are removed.
    ///
    /// This method provides a way for synchronous closure.
    pub fn r#close(&self) -> Result<(), fidl::Error> {
        RuleSetV6ProxyInterface::r#close(self)
    }

    /// Adds a rule to this rule set.
    ///
    /// If there is already a rule at the provided `index`, `RULE_ALREADY_EXISTS`
    /// is returned.
    ///
    /// + request `index` where to insert the rule.
    /// + request `matcher` the matcher of the rule.
    /// + request `action` action of the rule.
    pub fn r#add_rule(
        &self,
        mut index: u32,
        mut matcher: &fdomain_fuchsia_net_routes::RuleMatcherV6,
        mut action: &fdomain_fuchsia_net_routes::RuleAction,
    ) -> fidl::client::QueryResponseFut<
        RuleSetV6AddRuleResult,
        fdomain_client::fidl::FDomainResourceDialect,
    > {
        RuleSetV6ProxyInterface::r#add_rule(self, index, matcher, action)
    }
}

impl RuleSetV6ProxyInterface for RuleSetV6Proxy {
    type AuthenticateForRouteTableResponseFut = fidl::client::QueryResponseFut<
        BaseRuleSetAuthenticateForRouteTableResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#authenticate_for_route_table(
        &self,
        mut table: u32,
        mut token: fdomain_client::Event,
    ) -> Self::AuthenticateForRouteTableResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseRuleSetAuthenticateForRouteTableResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    AuthenticateForRouteTableError,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
                0x6fd845360ed9bc8f,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            ProofOfRouteTableAuthorization,
            BaseRuleSetAuthenticateForRouteTableResult,
        >(
            (table, token,),
            0x6fd845360ed9bc8f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type RemoveRuleResponseFut = fidl::client::QueryResponseFut<
        BaseRuleSetRemoveRuleResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#remove_rule(&self, mut index: u32) -> Self::RemoveRuleResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseRuleSetRemoveRuleResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, RuleSetError>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x2ae3d7e817cbff90,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BaseRuleSetRemoveRuleRequest, BaseRuleSetRemoveRuleResult>(
                (index,),
                0x2ae3d7e817cbff90,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

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

    type AddRuleResponseFut = fidl::client::QueryResponseFut<
        RuleSetV6AddRuleResult,
        fdomain_client::fidl::FDomainResourceDialect,
    >;
    fn r#add_rule(
        &self,
        mut index: u32,
        mut matcher: &fdomain_fuchsia_net_routes::RuleMatcherV6,
        mut action: &fdomain_fuchsia_net_routes::RuleAction,
    ) -> Self::AddRuleResponseFut {
        fn _decode(
            mut _buf: Result<<fdomain_client::fidl::FDomainResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RuleSetV6AddRuleResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, RuleSetError>,
                fdomain_client::fidl::FDomainResourceDialect,
                0x946cad8f8a726b3,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<RuleSetV6AddRuleRequest, RuleSetV6AddRuleResult>(
            (index, matcher, action),
            0x946cad8f8a726b3,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

pub struct RuleSetV6EventStream {
    event_receiver: fidl::client::EventReceiver<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.net.routes.admin/RuleSetV6.
pub struct RuleSetV6RequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fdomain_client::fidl::RequestStream for RuleSetV6RequestStream {
    type Protocol = RuleSetV6Marker;
    type ControlHandle = RuleSetV6ControlHandle;

    fn from_channel(channel: fdomain_client::Channel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        RuleSetV6ControlHandle { inner: self.inner.clone() }
    }

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

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

impl futures::Stream for RuleSetV6RequestStream {
    type Item = Result<RuleSetV6Request, 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 RuleSetV6RequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |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(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(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 {
                    0x6fd845360ed9bc8f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ProofOfRouteTableAuthorization,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<ProofOfRouteTableAuthorization>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RuleSetV6ControlHandle { inner: this.inner.clone() };
                        Ok(RuleSetV6Request::AuthenticateForRouteTable {
                            table: req.table,
                            token: req.token,

                            responder: RuleSetV6AuthenticateForRouteTableResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2ae3d7e817cbff90 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseRuleSetRemoveRuleRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<BaseRuleSetRemoveRuleRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RuleSetV6ControlHandle { inner: this.inner.clone() };
                        Ok(RuleSetV6Request::RemoveRule {
                            index: req.index,

                            responder: RuleSetV6RemoveRuleResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x457e1753672d4073 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RuleSetV6ControlHandle { inner: this.inner.clone() };
                        Ok(RuleSetV6Request::Close { control_handle })
                    }
                    0x946cad8f8a726b3 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RuleSetV6AddRuleRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<RuleSetV6AddRuleRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RuleSetV6ControlHandle { inner: this.inner.clone() };
                        Ok(RuleSetV6Request::AddRule {
                            index: req.index,
                            matcher: req.matcher,
                            action: req.action,

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

/// Provides mutable access over a set of the system's IPv6 route rules.
///
/// A `RuleSet` has a priority and a rule has an index. A global order among the
/// rules is determined first by the priority of the `RuleSet` the rule belongs
/// to, and then the index of the rule inside the `RuleSet`.
///
/// This protocol encodes the lifetime of the rule set. Closing the client end
/// removes the rule set, and all the rules that are owned by the rule set.
#[derive(Debug)]
pub enum RuleSetV6Request {
    /// Authenticates for a route table that will be used in an action.
    AuthenticateForRouteTable {
        table: u32,
        token: fdomain_client::Event,
        responder: RuleSetV6AuthenticateForRouteTableResponder,
    },
    /// Removes a rule from this rule set.
    ///
    /// If the client tries to remove from an index that does not have a rule,
    /// the error `RULE_DOES_NOT_EXIST` will be returned.
    ///
    /// + request `index` the index of the rule.
    RemoveRule { index: u32, responder: RuleSetV6RemoveRuleResponder },
    /// Removes all rules in the rule set and the underlying channel will be
    /// closed after the rules are removed.
    ///
    /// This method provides a way for synchronous closure.
    Close { control_handle: RuleSetV6ControlHandle },
    /// Adds a rule to this rule set.
    ///
    /// If there is already a rule at the provided `index`, `RULE_ALREADY_EXISTS`
    /// is returned.
    ///
    /// + request `index` where to insert the rule.
    /// + request `matcher` the matcher of the rule.
    /// + request `action` action of the rule.
    AddRule {
        index: u32,
        matcher: fdomain_fuchsia_net_routes::RuleMatcherV6,
        action: fdomain_fuchsia_net_routes::RuleAction,
        responder: RuleSetV6AddRuleResponder,
    },
}

impl RuleSetV6Request {
    #[allow(irrefutable_let_patterns)]
    pub fn into_authenticate_for_route_table(
        self,
    ) -> Option<(u32, fdomain_client::Event, RuleSetV6AuthenticateForRouteTableResponder)> {
        if let RuleSetV6Request::AuthenticateForRouteTable { table, token, responder } = self {
            Some((table, token, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_remove_rule(self) -> Option<(u32, RuleSetV6RemoveRuleResponder)> {
        if let RuleSetV6Request::RemoveRule { index, responder } = self {
            Some((index, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_close(self) -> Option<(RuleSetV6ControlHandle)> {
        if let RuleSetV6Request::Close { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_rule(
        self,
    ) -> Option<(
        u32,
        fdomain_fuchsia_net_routes::RuleMatcherV6,
        fdomain_fuchsia_net_routes::RuleAction,
        RuleSetV6AddRuleResponder,
    )> {
        if let RuleSetV6Request::AddRule { index, matcher, action, responder } = self {
            Some((index, matcher, action, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            RuleSetV6Request::AuthenticateForRouteTable { .. } => "authenticate_for_route_table",
            RuleSetV6Request::RemoveRule { .. } => "remove_rule",
            RuleSetV6Request::Close { .. } => "close",
            RuleSetV6Request::AddRule { .. } => "add_rule",
        }
    }
}

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

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

impl fdomain_client::fidl::ControlHandle for RuleSetV6ControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

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

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fdomain_client::OnFDomainSignals {
        self.inner.channel().on_closed()
    }
}

impl RuleSetV6ControlHandle {}

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

/// Set the the channel to be shutdown (see [`RuleSetV6ControlHandle::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 RuleSetV6AuthenticateForRouteTableResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for RuleSetV6AuthenticateForRouteTableResponder {
    type ControlHandle = RuleSetV6ControlHandle;

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

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

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

/// Set the the channel to be shutdown (see [`RuleSetV6ControlHandle::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 RuleSetV6RemoveRuleResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for RuleSetV6RemoveRuleResponder {
    type ControlHandle = RuleSetV6ControlHandle;

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

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

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

/// Set the the channel to be shutdown (see [`RuleSetV6ControlHandle::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 RuleSetV6AddRuleResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fdomain_client::fidl::Responder for RuleSetV6AddRuleResponder {
    type ControlHandle = RuleSetV6ControlHandle;

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

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

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

impl fdomain_client::fidl::ProtocolMarker for RuleTableV4Marker {
    type Proxy = RuleTableV4Proxy;
    type RequestStream = RuleTableV4RequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.net.routes.admin.RuleTableV4";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for RuleTableV4Marker {}

pub trait RuleTableV4ProxyInterface: Send + Sync {
    fn r#new_rule_set(
        &self,
        priority: u32,
        rule_set: fdomain_client::fidl::ServerEnd<RuleSetV4Marker>,
    ) -> Result<(), fidl::Error>;
}

#[derive(Debug, Clone)]
pub struct RuleTableV4Proxy {
    client: fidl::client::Client<fdomain_client::fidl::FDomainResourceDialect>,
}

impl fdomain_client::fidl::Proxy for RuleTableV4Proxy {
    type Protocol = RuleTableV4Marker;

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

    fn into_channel(self) -> Result<fdomain_client::Channel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

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

impl RuleTableV4Proxy {
    /// Create a new Proxy for fuchsia.net.routes.admin/RuleTableV4.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name = <RuleTableV4Marker as fdomain_client::fidl::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) -> RuleTableV4EventStream {
        RuleTableV4EventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Returns an empty rule set at requested priority.
    ///
    /// Clients are free to manage the rules within their own rule set, but not
    /// the rule set of others. Only one rule set is allowed at each `priority`
    /// level. Channel is closed with `ZX_ERR_ALREADY_EXISTS` if there's already
    /// a rule set at the given `priority`.
    ///
    /// + request `priority` the priority of this `RuleSetV4`, all rule sets are
    ///   globally ordered according to this number.
    /// + request `rule_set` grants access to the `RuleSetV4` protocol.
    pub fn r#new_rule_set(
        &self,
        mut priority: u32,
        mut rule_set: fdomain_client::fidl::ServerEnd<RuleSetV4Marker>,
    ) -> Result<(), fidl::Error> {
        RuleTableV4ProxyInterface::r#new_rule_set(self, priority, rule_set)
    }
}

impl RuleTableV4ProxyInterface for RuleTableV4Proxy {
    fn r#new_rule_set(
        &self,
        mut priority: u32,
        mut rule_set: fdomain_client::fidl::ServerEnd<RuleSetV4Marker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<RuleTableV4NewRuleSetRequest>(
            (priority, rule_set),
            0xa32a9097da46f3a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

pub struct RuleTableV4EventStream {
    event_receiver: fidl::client::EventReceiver<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.net.routes.admin/RuleTableV4.
pub struct RuleTableV4RequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fdomain_client::fidl::RequestStream for RuleTableV4RequestStream {
    type Protocol = RuleTableV4Marker;
    type ControlHandle = RuleTableV4ControlHandle;

    fn from_channel(channel: fdomain_client::Channel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        RuleTableV4ControlHandle { inner: self.inner.clone() }
    }

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

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

impl futures::Stream for RuleTableV4RequestStream {
    type Item = Result<RuleTableV4Request, 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 RuleTableV4RequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |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(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(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 {
                    0xa32a9097da46f3a => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            RuleTableV4NewRuleSetRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<RuleTableV4NewRuleSetRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RuleTableV4ControlHandle { inner: this.inner.clone() };
                        Ok(RuleTableV4Request::NewRuleSet {
                            priority: req.priority,
                            rule_set: req.rule_set,

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

/// Gives isolated access to the system's policy routing rules.
#[derive(Debug)]
pub enum RuleTableV4Request {
    /// Returns an empty rule set at requested priority.
    ///
    /// Clients are free to manage the rules within their own rule set, but not
    /// the rule set of others. Only one rule set is allowed at each `priority`
    /// level. Channel is closed with `ZX_ERR_ALREADY_EXISTS` if there's already
    /// a rule set at the given `priority`.
    ///
    /// + request `priority` the priority of this `RuleSetV4`, all rule sets are
    ///   globally ordered according to this number.
    /// + request `rule_set` grants access to the `RuleSetV4` protocol.
    NewRuleSet {
        priority: u32,
        rule_set: fdomain_client::fidl::ServerEnd<RuleSetV4Marker>,
        control_handle: RuleTableV4ControlHandle,
    },
}

impl RuleTableV4Request {
    #[allow(irrefutable_let_patterns)]
    pub fn into_new_rule_set(
        self,
    ) -> Option<(u32, fdomain_client::fidl::ServerEnd<RuleSetV4Marker>, RuleTableV4ControlHandle)>
    {
        if let RuleTableV4Request::NewRuleSet { priority, rule_set, control_handle } = self {
            Some((priority, rule_set, control_handle))
        } else {
            None
        }
    }

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

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

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

impl fdomain_client::fidl::ControlHandle for RuleTableV4ControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

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

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fdomain_client::OnFDomainSignals {
        self.inner.channel().on_closed()
    }
}

impl RuleTableV4ControlHandle {}

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

impl fdomain_client::fidl::ProtocolMarker for RuleTableV6Marker {
    type Proxy = RuleTableV6Proxy;
    type RequestStream = RuleTableV6RequestStream;

    const DEBUG_NAME: &'static str = "fuchsia.net.routes.admin.RuleTableV6";
}
impl fdomain_client::fidl::DiscoverableProtocolMarker for RuleTableV6Marker {}

pub trait RuleTableV6ProxyInterface: Send + Sync {
    fn r#new_rule_set(
        &self,
        priority: u32,
        rule_set: fdomain_client::fidl::ServerEnd<RuleSetV6Marker>,
    ) -> Result<(), fidl::Error>;
}

#[derive(Debug, Clone)]
pub struct RuleTableV6Proxy {
    client: fidl::client::Client<fdomain_client::fidl::FDomainResourceDialect>,
}

impl fdomain_client::fidl::Proxy for RuleTableV6Proxy {
    type Protocol = RuleTableV6Marker;

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

    fn into_channel(self) -> Result<fdomain_client::Channel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

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

impl RuleTableV6Proxy {
    /// Create a new Proxy for fuchsia.net.routes.admin/RuleTableV6.
    pub fn new(channel: fdomain_client::Channel) -> Self {
        let protocol_name = <RuleTableV6Marker as fdomain_client::fidl::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) -> RuleTableV6EventStream {
        RuleTableV6EventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Returns an empty rule set at requested priority.
    ///
    /// Clients are free to manage the rules within their own rule set, but not
    /// the rule set of others. Only one rule set is allowed at each `priority`
    /// level. Channel is closed with `ZX_ERR_ALREADY_EXISTS` if there's already
    /// a rule set at the given `priority`.
    ///
    /// + request `priority` the priority of this `RuleSetV6`, all rule sets are
    ///   globally ordered according to this number.
    /// + request `rule_set` grants access to the `RuleSetV6` protocol.
    pub fn r#new_rule_set(
        &self,
        mut priority: u32,
        mut rule_set: fdomain_client::fidl::ServerEnd<RuleSetV6Marker>,
    ) -> Result<(), fidl::Error> {
        RuleTableV6ProxyInterface::r#new_rule_set(self, priority, rule_set)
    }
}

impl RuleTableV6ProxyInterface for RuleTableV6Proxy {
    fn r#new_rule_set(
        &self,
        mut priority: u32,
        mut rule_set: fdomain_client::fidl::ServerEnd<RuleSetV6Marker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<RuleTableV6NewRuleSetRequest>(
            (priority, rule_set),
            0x2261cc6eee9726a0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

pub struct RuleTableV6EventStream {
    event_receiver: fidl::client::EventReceiver<fdomain_client::fidl::FDomainResourceDialect>,
}

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.net.routes.admin/RuleTableV6.
pub struct RuleTableV6RequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fdomain_client::fidl::FDomainResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fdomain_client::fidl::RequestStream for RuleTableV6RequestStream {
    type Protocol = RuleTableV6Marker;
    type ControlHandle = RuleTableV6ControlHandle;

    fn from_channel(channel: fdomain_client::Channel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        RuleTableV6ControlHandle { inner: self.inner.clone() }
    }

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

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

impl futures::Stream for RuleTableV6RequestStream {
    type Item = Result<RuleTableV6Request, 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 RuleTableV6RequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fdomain_client::fidl::FDomainResourceDialect>(
            |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(None)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(Some(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 {
                    0x2261cc6eee9726a0 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            RuleTableV6NewRuleSetRequest,
                            fdomain_client::fidl::FDomainResourceDialect
                        );
                        fidl::encoding::Decoder::<fdomain_client::fidl::FDomainResourceDialect>::decode_into::<RuleTableV6NewRuleSetRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RuleTableV6ControlHandle { inner: this.inner.clone() };
                        Ok(RuleTableV6Request::NewRuleSet {
                            priority: req.priority,
                            rule_set: req.rule_set,

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

/// Gives isolated access to the system's policy routing rules.
#[derive(Debug)]
pub enum RuleTableV6Request {
    /// Returns an empty rule set at requested priority.
    ///
    /// Clients are free to manage the rules within their own rule set, but not
    /// the rule set of others. Only one rule set is allowed at each `priority`
    /// level. Channel is closed with `ZX_ERR_ALREADY_EXISTS` if there's already
    /// a rule set at the given `priority`.
    ///
    /// + request `priority` the priority of this `RuleSetV6`, all rule sets are
    ///   globally ordered according to this number.
    /// + request `rule_set` grants access to the `RuleSetV6` protocol.
    NewRuleSet {
        priority: u32,
        rule_set: fdomain_client::fidl::ServerEnd<RuleSetV6Marker>,
        control_handle: RuleTableV6ControlHandle,
    },
}

impl RuleTableV6Request {
    #[allow(irrefutable_let_patterns)]
    pub fn into_new_rule_set(
        self,
    ) -> Option<(u32, fdomain_client::fidl::ServerEnd<RuleSetV6Marker>, RuleTableV6ControlHandle)>
    {
        if let RuleTableV6Request::NewRuleSet { priority, rule_set, control_handle } = self {
            Some((priority, rule_set, control_handle))
        } else {
            None
        }
    }

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

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

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

impl fdomain_client::fidl::ControlHandle for RuleTableV6ControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

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

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fdomain_client::OnFDomainSignals {
        self.inner.channel().on_closed()
    }
}

impl RuleTableV6ControlHandle {}

mod internal {
    use super::*;

    impl fidl::encoding::ResourceTypeMarker for BaseRouteTableGetAuthorizationForRouteTableResponse {
        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 BaseRouteTableGetAuthorizationForRouteTableResponse {
        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<
            BaseRouteTableGetAuthorizationForRouteTableResponse,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut BaseRouteTableGetAuthorizationForRouteTableResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder
                .debug_check_bounds::<BaseRouteTableGetAuthorizationForRouteTableResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<BaseRouteTableGetAuthorizationForRouteTableResponse, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <GrantForRouteTableAuthorization as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.credential),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                GrantForRouteTableAuthorization,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            BaseRouteTableGetAuthorizationForRouteTableResponse,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder
                .debug_check_bounds::<BaseRouteTableGetAuthorizationForRouteTableResponse>(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, fdomain_client::fidl::FDomainResourceDialect>
        for BaseRouteTableGetAuthorizationForRouteTableResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                credential: fidl::new_empty!(
                    GrantForRouteTableAuthorization,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for GrantForRouteTableAuthorization {
        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 GrantForRouteTableAuthorization {
        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<
            GrantForRouteTableAuthorization,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut GrantForRouteTableAuthorization
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<GrantForRouteTableAuthorization>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                GrantForRouteTableAuthorization,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.table_id),
                    <fidl::encoding::HandleType<
                        fdomain_client::Event,
                        { fidl::ObjectType::EVENT.into_raw() },
                        3,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.token
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<u32, fdomain_client::fidl::FDomainResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fdomain_client::Event,
                    { fidl::ObjectType::EVENT.into_raw() },
                    3,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            GrantForRouteTableAuthorization,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<GrantForRouteTableAuthorization>(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, fdomain_client::fidl::FDomainResourceDialect>
        for GrantForRouteTableAuthorization
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                table_id: fidl::new_empty!(u32, fdomain_client::fidl::FDomainResourceDialect),
                token: fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Event, { fidl::ObjectType::EVENT.into_raw() }, 3>, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                u32,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.table_id,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(fidl::encoding::HandleType<fdomain_client::Event, { fidl::ObjectType::EVENT.into_raw() }, 3>, fdomain_client::fidl::FDomainResourceDialect, &mut self.token, decoder, offset + 4, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ProofOfRouteTableAuthorization {
        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 ProofOfRouteTableAuthorization {
        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<
            ProofOfRouteTableAuthorization,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut ProofOfRouteTableAuthorization
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ProofOfRouteTableAuthorization>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                ProofOfRouteTableAuthorization,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.table),
                    <fidl::encoding::HandleType<
                        fdomain_client::Event,
                        { fidl::ObjectType::EVENT.into_raw() },
                        0,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.token
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<u32, fdomain_client::fidl::FDomainResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fdomain_client::Event,
                    { fidl::ObjectType::EVENT.into_raw() },
                    0,
                >,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            ProofOfRouteTableAuthorization,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ProofOfRouteTableAuthorization>(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, fdomain_client::fidl::FDomainResourceDialect>
        for ProofOfRouteTableAuthorization
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                table: fidl::new_empty!(u32, fdomain_client::fidl::FDomainResourceDialect),
                token: fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Event, { fidl::ObjectType::EVENT.into_raw() }, 0>, fdomain_client::fidl::FDomainResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                u32,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.table,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(fidl::encoding::HandleType<fdomain_client::Event, { fidl::ObjectType::EVENT.into_raw() }, 0>, fdomain_client::fidl::FDomainResourceDialect, &mut self.token, decoder, offset + 4, _depth)?;
            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            RouteSetV4AddRouteRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut RouteSetV4AddRouteRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RouteSetV4AddRouteRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                RouteSetV4AddRouteRequest,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (<fdomain_fuchsia_net_routes::RouteV4 as fidl::encoding::ValueTypeMarker>::borrow(
                    &self.route,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fdomain_fuchsia_net_routes::RouteV4,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            RouteSetV4AddRouteRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RouteSetV4AddRouteRequest>(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, fdomain_client::fidl::FDomainResourceDialect>
        for RouteSetV4AddRouteRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                route: fidl::new_empty!(
                    fdomain_fuchsia_net_routes::RouteV4,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            RouteSetV4AuthenticateForInterfaceRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut RouteSetV4AuthenticateForInterfaceRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RouteSetV4AuthenticateForInterfaceRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RouteSetV4AuthenticateForInterfaceRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fdomain_fuchsia_net_resources::ProofOfInterfaceAuthorization as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.credential),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fdomain_fuchsia_net_resources::ProofOfInterfaceAuthorization,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            RouteSetV4AuthenticateForInterfaceRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RouteSetV4AuthenticateForInterfaceRequest>(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, fdomain_client::fidl::FDomainResourceDialect>
        for RouteSetV4AuthenticateForInterfaceRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                credential: fidl::new_empty!(
                    fdomain_fuchsia_net_resources::ProofOfInterfaceAuthorization,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            RouteSetV4RemoveRouteRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut RouteSetV4RemoveRouteRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RouteSetV4RemoveRouteRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                RouteSetV4RemoveRouteRequest,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (<fdomain_fuchsia_net_routes::RouteV4 as fidl::encoding::ValueTypeMarker>::borrow(
                    &self.route,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fdomain_fuchsia_net_routes::RouteV4,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            RouteSetV4RemoveRouteRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RouteSetV4RemoveRouteRequest>(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, fdomain_client::fidl::FDomainResourceDialect>
        for RouteSetV4RemoveRouteRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                route: fidl::new_empty!(
                    fdomain_fuchsia_net_routes::RouteV4,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            RouteSetV6AddRouteRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut RouteSetV6AddRouteRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RouteSetV6AddRouteRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                RouteSetV6AddRouteRequest,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (<fdomain_fuchsia_net_routes::RouteV6 as fidl::encoding::ValueTypeMarker>::borrow(
                    &self.route,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fdomain_fuchsia_net_routes::RouteV6,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            RouteSetV6AddRouteRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RouteSetV6AddRouteRequest>(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, fdomain_client::fidl::FDomainResourceDialect>
        for RouteSetV6AddRouteRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                route: fidl::new_empty!(
                    fdomain_fuchsia_net_routes::RouteV6,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            RouteSetV6AuthenticateForInterfaceRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut RouteSetV6AuthenticateForInterfaceRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RouteSetV6AuthenticateForInterfaceRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RouteSetV6AuthenticateForInterfaceRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fdomain_fuchsia_net_resources::ProofOfInterfaceAuthorization as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.credential),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fdomain_fuchsia_net_resources::ProofOfInterfaceAuthorization,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            RouteSetV6AuthenticateForInterfaceRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RouteSetV6AuthenticateForInterfaceRequest>(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, fdomain_client::fidl::FDomainResourceDialect>
        for RouteSetV6AuthenticateForInterfaceRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                credential: fidl::new_empty!(
                    fdomain_fuchsia_net_resources::ProofOfInterfaceAuthorization,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            RouteSetV6RemoveRouteRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut RouteSetV6RemoveRouteRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RouteSetV6RemoveRouteRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                RouteSetV6RemoveRouteRequest,
                fdomain_client::fidl::FDomainResourceDialect,
            >::encode(
                (<fdomain_fuchsia_net_routes::RouteV6 as fidl::encoding::ValueTypeMarker>::borrow(
                    &self.route,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fdomain_fuchsia_net_routes::RouteV6,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            RouteSetV6RemoveRouteRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RouteSetV6RemoveRouteRequest>(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, fdomain_client::fidl::FDomainResourceDialect>
        for RouteSetV6RemoveRouteRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                route: fidl::new_empty!(
                    fdomain_fuchsia_net_routes::RouteV6,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            RouteTableProviderV4GetInterfaceLocalTableRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut RouteTableProviderV4GetInterfaceLocalTableRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RouteTableProviderV4GetInterfaceLocalTableRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RouteTableProviderV4GetInterfaceLocalTableRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fdomain_fuchsia_net_resources::ProofOfInterfaceAuthorization as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.credential),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fdomain_fuchsia_net_resources::ProofOfInterfaceAuthorization,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            RouteTableProviderV4GetInterfaceLocalTableRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RouteTableProviderV4GetInterfaceLocalTableRequest>(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, fdomain_client::fidl::FDomainResourceDialect>
        for RouteTableProviderV4GetInterfaceLocalTableRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                credential: fidl::new_empty!(
                    fdomain_fuchsia_net_resources::ProofOfInterfaceAuthorization,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

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

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

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

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

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

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for RouteTableProviderV4NewRouteTableRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                provider: fidl::new_empty!(
                    fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<RouteTableV4Marker>>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                options: fidl::new_empty!(
                    RouteTableOptionsV4,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for RouteTableProviderV4GetInterfaceLocalTableResponse {
        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 RouteTableProviderV4GetInterfaceLocalTableResponse {
        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<
            RouteTableProviderV4GetInterfaceLocalTableResponse,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut RouteTableProviderV4GetInterfaceLocalTableResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder
                .debug_check_bounds::<RouteTableProviderV4GetInterfaceLocalTableResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RouteTableProviderV4GetInterfaceLocalTableResponse, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fdomain_client::fidl::ClientEnd<RouteTableV4Marker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.route_table),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fdomain_client::fidl::ClientEnd<RouteTableV4Marker>>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            RouteTableProviderV4GetInterfaceLocalTableResponse,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder
                .debug_check_bounds::<RouteTableProviderV4GetInterfaceLocalTableResponse>(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, fdomain_client::fidl::FDomainResourceDialect>
        for RouteTableProviderV4GetInterfaceLocalTableResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                route_table: fidl::new_empty!(
                    fidl::encoding::Endpoint<fdomain_client::fidl::ClientEnd<RouteTableV4Marker>>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            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<fdomain_client::fidl::ClientEnd<RouteTableV4Marker>>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.route_table,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            RouteTableProviderV6GetInterfaceLocalTableRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut RouteTableProviderV6GetInterfaceLocalTableRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RouteTableProviderV6GetInterfaceLocalTableRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RouteTableProviderV6GetInterfaceLocalTableRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fdomain_fuchsia_net_resources::ProofOfInterfaceAuthorization as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.credential),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fdomain_fuchsia_net_resources::ProofOfInterfaceAuthorization,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            RouteTableProviderV6GetInterfaceLocalTableRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RouteTableProviderV6GetInterfaceLocalTableRequest>(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, fdomain_client::fidl::FDomainResourceDialect>
        for RouteTableProviderV6GetInterfaceLocalTableRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                credential: fidl::new_empty!(
                    fdomain_fuchsia_net_resources::ProofOfInterfaceAuthorization,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

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

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

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

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

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

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for RouteTableProviderV6NewRouteTableRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                provider: fidl::new_empty!(
                    fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<RouteTableV6Marker>>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                options: fidl::new_empty!(
                    RouteTableOptionsV6,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for RouteTableProviderV6GetInterfaceLocalTableResponse {
        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 RouteTableProviderV6GetInterfaceLocalTableResponse {
        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<
            RouteTableProviderV6GetInterfaceLocalTableResponse,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut RouteTableProviderV6GetInterfaceLocalTableResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder
                .debug_check_bounds::<RouteTableProviderV6GetInterfaceLocalTableResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RouteTableProviderV6GetInterfaceLocalTableResponse, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fdomain_client::fidl::ClientEnd<RouteTableV6Marker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.route_table),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fdomain_client::fidl::ClientEnd<RouteTableV6Marker>>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            RouteTableProviderV6GetInterfaceLocalTableResponse,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder
                .debug_check_bounds::<RouteTableProviderV6GetInterfaceLocalTableResponse>(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, fdomain_client::fidl::FDomainResourceDialect>
        for RouteTableProviderV6GetInterfaceLocalTableResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                route_table: fidl::new_empty!(
                    fidl::encoding::Endpoint<fdomain_client::fidl::ClientEnd<RouteTableV6Marker>>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            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<fdomain_client::fidl::ClientEnd<RouteTableV6Marker>>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.route_table,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for RouteTableV4NewRouteSetRequest {
        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 RouteTableV4NewRouteSetRequest {
        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<
            RouteTableV4NewRouteSetRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut RouteTableV4NewRouteSetRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RouteTableV4NewRouteSetRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RouteTableV4NewRouteSetRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<RouteSetV4Marker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.route_set),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<RouteSetV4Marker>>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            RouteTableV4NewRouteSetRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RouteTableV4NewRouteSetRequest>(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, fdomain_client::fidl::FDomainResourceDialect>
        for RouteTableV4NewRouteSetRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                route_set: fidl::new_empty!(
                    fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<RouteSetV4Marker>>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            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<fdomain_client::fidl::ServerEnd<RouteSetV4Marker>>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.route_set,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for RouteTableV6NewRouteSetRequest {
        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 RouteTableV6NewRouteSetRequest {
        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<
            RouteTableV6NewRouteSetRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut RouteTableV6NewRouteSetRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RouteTableV6NewRouteSetRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RouteTableV6NewRouteSetRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<RouteSetV6Marker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.route_set),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<RouteSetV6Marker>>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            RouteTableV6NewRouteSetRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RouteTableV6NewRouteSetRequest>(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, fdomain_client::fidl::FDomainResourceDialect>
        for RouteTableV6NewRouteSetRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                route_set: fidl::new_empty!(
                    fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<RouteSetV6Marker>>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            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<fdomain_client::fidl::ServerEnd<RouteSetV6Marker>>,
                fdomain_client::fidl::FDomainResourceDialect,
                &mut self.route_set,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            RuleSetV4AddRuleRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut RuleSetV4AddRuleRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RuleSetV4AddRuleRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RuleSetV4AddRuleRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.index),
                    <fdomain_fuchsia_net_routes::RuleMatcherV4 as fidl::encoding::ValueTypeMarker>::borrow(&self.matcher),
                    <fdomain_fuchsia_net_routes::RuleAction as fidl::encoding::ValueTypeMarker>::borrow(&self.action),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<u32, fdomain_client::fidl::FDomainResourceDialect>,
        T1: fidl::encoding::Encode<
                fdomain_fuchsia_net_routes::RuleMatcherV4,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T2: fidl::encoding::Encode<
                fdomain_fuchsia_net_routes::RuleAction,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            RuleSetV4AddRuleRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RuleSetV4AddRuleRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            self.2.encode(encoder, offset + 24, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for RuleSetV4AddRuleRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                index: fidl::new_empty!(u32, fdomain_client::fidl::FDomainResourceDialect),
                matcher: fidl::new_empty!(
                    fdomain_fuchsia_net_routes::RuleMatcherV4,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                action: fidl::new_empty!(
                    fdomain_fuchsia_net_routes::RuleAction,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            RuleSetV6AddRuleRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut RuleSetV6AddRuleRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RuleSetV6AddRuleRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RuleSetV6AddRuleRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.index),
                    <fdomain_fuchsia_net_routes::RuleMatcherV6 as fidl::encoding::ValueTypeMarker>::borrow(&self.matcher),
                    <fdomain_fuchsia_net_routes::RuleAction as fidl::encoding::ValueTypeMarker>::borrow(&self.action),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<u32, fdomain_client::fidl::FDomainResourceDialect>,
        T1: fidl::encoding::Encode<
                fdomain_fuchsia_net_routes::RuleMatcherV6,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
        T2: fidl::encoding::Encode<
                fdomain_fuchsia_net_routes::RuleAction,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            RuleSetV6AddRuleRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RuleSetV6AddRuleRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            self.2.encode(encoder, offset + 24, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
        for RuleSetV6AddRuleRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                index: fidl::new_empty!(u32, fdomain_client::fidl::FDomainResourceDialect),
                matcher: fidl::new_empty!(
                    fdomain_fuchsia_net_routes::RuleMatcherV6,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
                action: fidl::new_empty!(
                    fdomain_fuchsia_net_routes::RuleAction,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for RuleTableV4NewRuleSetRequest {
        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 RuleTableV4NewRuleSetRequest {
        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<
            RuleTableV4NewRuleSetRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut RuleTableV4NewRuleSetRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RuleTableV4NewRuleSetRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RuleTableV4NewRuleSetRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.priority),
                    <fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<RuleSetV4Marker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.rule_set),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<u32, fdomain_client::fidl::FDomainResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<RuleSetV4Marker>>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            RuleTableV4NewRuleSetRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RuleTableV4NewRuleSetRequest>(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, fdomain_client::fidl::FDomainResourceDialect>
        for RuleTableV4NewRuleSetRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                priority: fidl::new_empty!(u32, fdomain_client::fidl::FDomainResourceDialect),
                rule_set: fidl::new_empty!(
                    fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<RuleSetV4Marker>>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for RuleTableV6NewRuleSetRequest {
        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 RuleTableV6NewRuleSetRequest {
        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<
            RuleTableV6NewRuleSetRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for &mut RuleTableV6NewRuleSetRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RuleTableV6NewRuleSetRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RuleTableV6NewRuleSetRequest, fdomain_client::fidl::FDomainResourceDialect>::encode(
                (
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.priority),
                    <fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<RuleSetV6Marker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.rule_set),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<u32, fdomain_client::fidl::FDomainResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<RuleSetV6Marker>>,
                fdomain_client::fidl::FDomainResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            RuleTableV6NewRuleSetRequest,
            fdomain_client::fidl::FDomainResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RuleTableV6NewRuleSetRequest>(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, fdomain_client::fidl::FDomainResourceDialect>
        for RuleTableV6NewRuleSetRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                priority: fidl::new_empty!(u32, fdomain_client::fidl::FDomainResourceDialect),
                rule_set: fidl::new_empty!(
                    fidl::encoding::Endpoint<fdomain_client::fidl::ServerEnd<RuleSetV6Marker>>,
                    fdomain_client::fidl::FDomainResourceDialect
                ),
            }
        }

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