// This file is generated by rust-protobuf 2.8.1. Do not edit
// @generated

// https://github.com/Manishearth/rust-clippy/issues/702
#![allow(unknown_lints)]
#![allow(clippy::all)]

#![cfg_attr(rustfmt, rustfmt_skip)]

#![allow(box_pointers)]
#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unsafe_code)]
#![allow(unused_imports)]
#![allow(unused_results)]
//! Generated file from `as/external/api/networkServer.proto`

use protobuf::Message as Message_imported_for_functions;
use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions;

/// Generated files are compatible only with the same version
/// of protobuf runtime.
const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_8_1;

#[derive(PartialEq,Clone,Default)]
pub struct NetworkServer {
    // message fields
    pub id: i64,
    pub name: ::std::string::String,
    pub server: ::std::string::String,
    pub ca_cert: ::std::string::String,
    pub tls_cert: ::std::string::String,
    pub tls_key: ::std::string::String,
    pub routing_profile_ca_cert: ::std::string::String,
    pub routing_profile_tls_cert: ::std::string::String,
    pub routing_profile_tls_key: ::std::string::String,
    pub gateway_discovery_enabled: bool,
    pub gateway_discovery_interval: u32,
    pub gateway_discovery_tx_frequency: u32,
    pub gateway_discovery_dr: u32,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a NetworkServer {
    fn default() -> &'a NetworkServer {
        <NetworkServer as ::protobuf::Message>::default_instance()
    }
}

impl NetworkServer {
    pub fn new() -> NetworkServer {
        ::std::default::Default::default()
    }

    // int64 id = 1;


    pub fn get_id(&self) -> i64 {
        self.id
    }
    pub fn clear_id(&mut self) {
        self.id = 0;
    }

    // Param is passed by value, moved
    pub fn set_id(&mut self, v: i64) {
        self.id = v;
    }

    // string name = 2;


    pub fn get_name(&self) -> &str {
        &self.name
    }
    pub fn clear_name(&mut self) {
        self.name.clear();
    }

    // Param is passed by value, moved
    pub fn set_name(&mut self, v: ::std::string::String) {
        self.name = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_name(&mut self) -> &mut ::std::string::String {
        &mut self.name
    }

    // Take field
    pub fn take_name(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.name, ::std::string::String::new())
    }

    // string server = 3;


    pub fn get_server(&self) -> &str {
        &self.server
    }
    pub fn clear_server(&mut self) {
        self.server.clear();
    }

    // Param is passed by value, moved
    pub fn set_server(&mut self, v: ::std::string::String) {
        self.server = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_server(&mut self) -> &mut ::std::string::String {
        &mut self.server
    }

    // Take field
    pub fn take_server(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.server, ::std::string::String::new())
    }

    // string ca_cert = 4;


    pub fn get_ca_cert(&self) -> &str {
        &self.ca_cert
    }
    pub fn clear_ca_cert(&mut self) {
        self.ca_cert.clear();
    }

    // Param is passed by value, moved
    pub fn set_ca_cert(&mut self, v: ::std::string::String) {
        self.ca_cert = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_ca_cert(&mut self) -> &mut ::std::string::String {
        &mut self.ca_cert
    }

    // Take field
    pub fn take_ca_cert(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.ca_cert, ::std::string::String::new())
    }

    // string tls_cert = 5;


    pub fn get_tls_cert(&self) -> &str {
        &self.tls_cert
    }
    pub fn clear_tls_cert(&mut self) {
        self.tls_cert.clear();
    }

    // Param is passed by value, moved
    pub fn set_tls_cert(&mut self, v: ::std::string::String) {
        self.tls_cert = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_tls_cert(&mut self) -> &mut ::std::string::String {
        &mut self.tls_cert
    }

    // Take field
    pub fn take_tls_cert(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.tls_cert, ::std::string::String::new())
    }

    // string tls_key = 6;


    pub fn get_tls_key(&self) -> &str {
        &self.tls_key
    }
    pub fn clear_tls_key(&mut self) {
        self.tls_key.clear();
    }

    // Param is passed by value, moved
    pub fn set_tls_key(&mut self, v: ::std::string::String) {
        self.tls_key = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_tls_key(&mut self) -> &mut ::std::string::String {
        &mut self.tls_key
    }

    // Take field
    pub fn take_tls_key(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.tls_key, ::std::string::String::new())
    }

    // string routing_profile_ca_cert = 7;


    pub fn get_routing_profile_ca_cert(&self) -> &str {
        &self.routing_profile_ca_cert
    }
    pub fn clear_routing_profile_ca_cert(&mut self) {
        self.routing_profile_ca_cert.clear();
    }

    // Param is passed by value, moved
    pub fn set_routing_profile_ca_cert(&mut self, v: ::std::string::String) {
        self.routing_profile_ca_cert = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_routing_profile_ca_cert(&mut self) -> &mut ::std::string::String {
        &mut self.routing_profile_ca_cert
    }

    // Take field
    pub fn take_routing_profile_ca_cert(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.routing_profile_ca_cert, ::std::string::String::new())
    }

    // string routing_profile_tls_cert = 8;


    pub fn get_routing_profile_tls_cert(&self) -> &str {
        &self.routing_profile_tls_cert
    }
    pub fn clear_routing_profile_tls_cert(&mut self) {
        self.routing_profile_tls_cert.clear();
    }

    // Param is passed by value, moved
    pub fn set_routing_profile_tls_cert(&mut self, v: ::std::string::String) {
        self.routing_profile_tls_cert = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_routing_profile_tls_cert(&mut self) -> &mut ::std::string::String {
        &mut self.routing_profile_tls_cert
    }

    // Take field
    pub fn take_routing_profile_tls_cert(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.routing_profile_tls_cert, ::std::string::String::new())
    }

    // string routing_profile_tls_key = 9;


    pub fn get_routing_profile_tls_key(&self) -> &str {
        &self.routing_profile_tls_key
    }
    pub fn clear_routing_profile_tls_key(&mut self) {
        self.routing_profile_tls_key.clear();
    }

    // Param is passed by value, moved
    pub fn set_routing_profile_tls_key(&mut self, v: ::std::string::String) {
        self.routing_profile_tls_key = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_routing_profile_tls_key(&mut self) -> &mut ::std::string::String {
        &mut self.routing_profile_tls_key
    }

    // Take field
    pub fn take_routing_profile_tls_key(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.routing_profile_tls_key, ::std::string::String::new())
    }

    // bool gateway_discovery_enabled = 10;


    pub fn get_gateway_discovery_enabled(&self) -> bool {
        self.gateway_discovery_enabled
    }
    pub fn clear_gateway_discovery_enabled(&mut self) {
        self.gateway_discovery_enabled = false;
    }

    // Param is passed by value, moved
    pub fn set_gateway_discovery_enabled(&mut self, v: bool) {
        self.gateway_discovery_enabled = v;
    }

    // uint32 gateway_discovery_interval = 11;


    pub fn get_gateway_discovery_interval(&self) -> u32 {
        self.gateway_discovery_interval
    }
    pub fn clear_gateway_discovery_interval(&mut self) {
        self.gateway_discovery_interval = 0;
    }

    // Param is passed by value, moved
    pub fn set_gateway_discovery_interval(&mut self, v: u32) {
        self.gateway_discovery_interval = v;
    }

    // uint32 gateway_discovery_tx_frequency = 12;


    pub fn get_gateway_discovery_tx_frequency(&self) -> u32 {
        self.gateway_discovery_tx_frequency
    }
    pub fn clear_gateway_discovery_tx_frequency(&mut self) {
        self.gateway_discovery_tx_frequency = 0;
    }

    // Param is passed by value, moved
    pub fn set_gateway_discovery_tx_frequency(&mut self, v: u32) {
        self.gateway_discovery_tx_frequency = v;
    }

    // uint32 gateway_discovery_dr = 13;


    pub fn get_gateway_discovery_dr(&self) -> u32 {
        self.gateway_discovery_dr
    }
    pub fn clear_gateway_discovery_dr(&mut self) {
        self.gateway_discovery_dr = 0;
    }

    // Param is passed by value, moved
    pub fn set_gateway_discovery_dr(&mut self, v: u32) {
        self.gateway_discovery_dr = v;
    }
}

impl ::protobuf::Message for NetworkServer {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.id = tmp;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.server)?;
                },
                4 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.ca_cert)?;
                },
                5 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.tls_cert)?;
                },
                6 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.tls_key)?;
                },
                7 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.routing_profile_ca_cert)?;
                },
                8 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.routing_profile_tls_cert)?;
                },
                9 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.routing_profile_tls_key)?;
                },
                10 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.gateway_discovery_enabled = tmp;
                },
                11 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.gateway_discovery_interval = tmp;
                },
                12 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.gateway_discovery_tx_frequency = tmp;
                },
                13 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint32()?;
                    self.gateway_discovery_dr = tmp;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.id != 0 {
            my_size += ::protobuf::rt::value_size(1, self.id, ::protobuf::wire_format::WireTypeVarint);
        }
        if !self.name.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.name);
        }
        if !self.server.is_empty() {
            my_size += ::protobuf::rt::string_size(3, &self.server);
        }
        if !self.ca_cert.is_empty() {
            my_size += ::protobuf::rt::string_size(4, &self.ca_cert);
        }
        if !self.tls_cert.is_empty() {
            my_size += ::protobuf::rt::string_size(5, &self.tls_cert);
        }
        if !self.tls_key.is_empty() {
            my_size += ::protobuf::rt::string_size(6, &self.tls_key);
        }
        if !self.routing_profile_ca_cert.is_empty() {
            my_size += ::protobuf::rt::string_size(7, &self.routing_profile_ca_cert);
        }
        if !self.routing_profile_tls_cert.is_empty() {
            my_size += ::protobuf::rt::string_size(8, &self.routing_profile_tls_cert);
        }
        if !self.routing_profile_tls_key.is_empty() {
            my_size += ::protobuf::rt::string_size(9, &self.routing_profile_tls_key);
        }
        if self.gateway_discovery_enabled != false {
            my_size += 2;
        }
        if self.gateway_discovery_interval != 0 {
            my_size += ::protobuf::rt::value_size(11, self.gateway_discovery_interval, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.gateway_discovery_tx_frequency != 0 {
            my_size += ::protobuf::rt::value_size(12, self.gateway_discovery_tx_frequency, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.gateway_discovery_dr != 0 {
            my_size += ::protobuf::rt::value_size(13, self.gateway_discovery_dr, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if self.id != 0 {
            os.write_int64(1, self.id)?;
        }
        if !self.name.is_empty() {
            os.write_string(2, &self.name)?;
        }
        if !self.server.is_empty() {
            os.write_string(3, &self.server)?;
        }
        if !self.ca_cert.is_empty() {
            os.write_string(4, &self.ca_cert)?;
        }
        if !self.tls_cert.is_empty() {
            os.write_string(5, &self.tls_cert)?;
        }
        if !self.tls_key.is_empty() {
            os.write_string(6, &self.tls_key)?;
        }
        if !self.routing_profile_ca_cert.is_empty() {
            os.write_string(7, &self.routing_profile_ca_cert)?;
        }
        if !self.routing_profile_tls_cert.is_empty() {
            os.write_string(8, &self.routing_profile_tls_cert)?;
        }
        if !self.routing_profile_tls_key.is_empty() {
            os.write_string(9, &self.routing_profile_tls_key)?;
        }
        if self.gateway_discovery_enabled != false {
            os.write_bool(10, self.gateway_discovery_enabled)?;
        }
        if self.gateway_discovery_interval != 0 {
            os.write_uint32(11, self.gateway_discovery_interval)?;
        }
        if self.gateway_discovery_tx_frequency != 0 {
            os.write_uint32(12, self.gateway_discovery_tx_frequency)?;
        }
        if self.gateway_discovery_dr != 0 {
            os.write_uint32(13, self.gateway_discovery_dr)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> NetworkServer {
        NetworkServer::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "id",
                    |m: &NetworkServer| { &m.id },
                    |m: &mut NetworkServer| { &mut m.id },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "name",
                    |m: &NetworkServer| { &m.name },
                    |m: &mut NetworkServer| { &mut m.name },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "server",
                    |m: &NetworkServer| { &m.server },
                    |m: &mut NetworkServer| { &mut m.server },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "ca_cert",
                    |m: &NetworkServer| { &m.ca_cert },
                    |m: &mut NetworkServer| { &mut m.ca_cert },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "tls_cert",
                    |m: &NetworkServer| { &m.tls_cert },
                    |m: &mut NetworkServer| { &mut m.tls_cert },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "tls_key",
                    |m: &NetworkServer| { &m.tls_key },
                    |m: &mut NetworkServer| { &mut m.tls_key },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "routing_profile_ca_cert",
                    |m: &NetworkServer| { &m.routing_profile_ca_cert },
                    |m: &mut NetworkServer| { &mut m.routing_profile_ca_cert },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "routing_profile_tls_cert",
                    |m: &NetworkServer| { &m.routing_profile_tls_cert },
                    |m: &mut NetworkServer| { &mut m.routing_profile_tls_cert },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "routing_profile_tls_key",
                    |m: &NetworkServer| { &m.routing_profile_tls_key },
                    |m: &mut NetworkServer| { &mut m.routing_profile_tls_key },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                    "gateway_discovery_enabled",
                    |m: &NetworkServer| { &m.gateway_discovery_enabled },
                    |m: &mut NetworkServer| { &mut m.gateway_discovery_enabled },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                    "gateway_discovery_interval",
                    |m: &NetworkServer| { &m.gateway_discovery_interval },
                    |m: &mut NetworkServer| { &mut m.gateway_discovery_interval },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                    "gateway_discovery_tx_frequency",
                    |m: &NetworkServer| { &m.gateway_discovery_tx_frequency },
                    |m: &mut NetworkServer| { &mut m.gateway_discovery_tx_frequency },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
                    "gateway_discovery_dr",
                    |m: &NetworkServer| { &m.gateway_discovery_dr },
                    |m: &mut NetworkServer| { &mut m.gateway_discovery_dr },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<NetworkServer>(
                    "NetworkServer",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static NetworkServer {
        static mut instance: ::protobuf::lazy::Lazy<NetworkServer> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const NetworkServer,
        };
        unsafe {
            instance.get(NetworkServer::new)
        }
    }
}

impl ::protobuf::Clear for NetworkServer {
    fn clear(&mut self) {
        self.id = 0;
        self.name.clear();
        self.server.clear();
        self.ca_cert.clear();
        self.tls_cert.clear();
        self.tls_key.clear();
        self.routing_profile_ca_cert.clear();
        self.routing_profile_tls_cert.clear();
        self.routing_profile_tls_key.clear();
        self.gateway_discovery_enabled = false;
        self.gateway_discovery_interval = 0;
        self.gateway_discovery_tx_frequency = 0;
        self.gateway_discovery_dr = 0;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for NetworkServer {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for NetworkServer {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct NetworkServerListItem {
    // message fields
    pub id: i64,
    pub name: ::std::string::String,
    pub server: ::std::string::String,
    pub created_at: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>,
    pub updated_at: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a NetworkServerListItem {
    fn default() -> &'a NetworkServerListItem {
        <NetworkServerListItem as ::protobuf::Message>::default_instance()
    }
}

impl NetworkServerListItem {
    pub fn new() -> NetworkServerListItem {
        ::std::default::Default::default()
    }

    // int64 id = 1;


    pub fn get_id(&self) -> i64 {
        self.id
    }
    pub fn clear_id(&mut self) {
        self.id = 0;
    }

    // Param is passed by value, moved
    pub fn set_id(&mut self, v: i64) {
        self.id = v;
    }

    // string name = 2;


    pub fn get_name(&self) -> &str {
        &self.name
    }
    pub fn clear_name(&mut self) {
        self.name.clear();
    }

    // Param is passed by value, moved
    pub fn set_name(&mut self, v: ::std::string::String) {
        self.name = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_name(&mut self) -> &mut ::std::string::String {
        &mut self.name
    }

    // Take field
    pub fn take_name(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.name, ::std::string::String::new())
    }

    // string server = 3;


    pub fn get_server(&self) -> &str {
        &self.server
    }
    pub fn clear_server(&mut self) {
        self.server.clear();
    }

    // Param is passed by value, moved
    pub fn set_server(&mut self, v: ::std::string::String) {
        self.server = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_server(&mut self) -> &mut ::std::string::String {
        &mut self.server
    }

    // Take field
    pub fn take_server(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.server, ::std::string::String::new())
    }

    // .google.protobuf.Timestamp created_at = 4;


    pub fn get_created_at(&self) -> &::protobuf::well_known_types::Timestamp {
        self.created_at.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::default_instance())
    }
    pub fn clear_created_at(&mut self) {
        self.created_at.clear();
    }

    pub fn has_created_at(&self) -> bool {
        self.created_at.is_some()
    }

    // Param is passed by value, moved
    pub fn set_created_at(&mut self, v: ::protobuf::well_known_types::Timestamp) {
        self.created_at = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_created_at(&mut self) -> &mut ::protobuf::well_known_types::Timestamp {
        if self.created_at.is_none() {
            self.created_at.set_default();
        }
        self.created_at.as_mut().unwrap()
    }

    // Take field
    pub fn take_created_at(&mut self) -> ::protobuf::well_known_types::Timestamp {
        self.created_at.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new())
    }

    // .google.protobuf.Timestamp updated_at = 5;


    pub fn get_updated_at(&self) -> &::protobuf::well_known_types::Timestamp {
        self.updated_at.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::default_instance())
    }
    pub fn clear_updated_at(&mut self) {
        self.updated_at.clear();
    }

    pub fn has_updated_at(&self) -> bool {
        self.updated_at.is_some()
    }

    // Param is passed by value, moved
    pub fn set_updated_at(&mut self, v: ::protobuf::well_known_types::Timestamp) {
        self.updated_at = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_updated_at(&mut self) -> &mut ::protobuf::well_known_types::Timestamp {
        if self.updated_at.is_none() {
            self.updated_at.set_default();
        }
        self.updated_at.as_mut().unwrap()
    }

    // Take field
    pub fn take_updated_at(&mut self) -> ::protobuf::well_known_types::Timestamp {
        self.updated_at.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new())
    }
}

impl ::protobuf::Message for NetworkServerListItem {
    fn is_initialized(&self) -> bool {
        for v in &self.created_at {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.updated_at {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.id = tmp;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.server)?;
                },
                4 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.created_at)?;
                },
                5 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.updated_at)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.id != 0 {
            my_size += ::protobuf::rt::value_size(1, self.id, ::protobuf::wire_format::WireTypeVarint);
        }
        if !self.name.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.name);
        }
        if !self.server.is_empty() {
            my_size += ::protobuf::rt::string_size(3, &self.server);
        }
        if let Some(ref v) = self.created_at.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.updated_at.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if self.id != 0 {
            os.write_int64(1, self.id)?;
        }
        if !self.name.is_empty() {
            os.write_string(2, &self.name)?;
        }
        if !self.server.is_empty() {
            os.write_string(3, &self.server)?;
        }
        if let Some(ref v) = self.created_at.as_ref() {
            os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.updated_at.as_ref() {
            os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> NetworkServerListItem {
        NetworkServerListItem::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "id",
                    |m: &NetworkServerListItem| { &m.id },
                    |m: &mut NetworkServerListItem| { &mut m.id },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "name",
                    |m: &NetworkServerListItem| { &m.name },
                    |m: &mut NetworkServerListItem| { &mut m.name },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "server",
                    |m: &NetworkServerListItem| { &m.server },
                    |m: &mut NetworkServerListItem| { &mut m.server },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>(
                    "created_at",
                    |m: &NetworkServerListItem| { &m.created_at },
                    |m: &mut NetworkServerListItem| { &mut m.created_at },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>(
                    "updated_at",
                    |m: &NetworkServerListItem| { &m.updated_at },
                    |m: &mut NetworkServerListItem| { &mut m.updated_at },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<NetworkServerListItem>(
                    "NetworkServerListItem",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static NetworkServerListItem {
        static mut instance: ::protobuf::lazy::Lazy<NetworkServerListItem> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const NetworkServerListItem,
        };
        unsafe {
            instance.get(NetworkServerListItem::new)
        }
    }
}

impl ::protobuf::Clear for NetworkServerListItem {
    fn clear(&mut self) {
        self.id = 0;
        self.name.clear();
        self.server.clear();
        self.created_at.clear();
        self.updated_at.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for NetworkServerListItem {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for NetworkServerListItem {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CreateNetworkServerRequest {
    // message fields
    pub network_server: ::protobuf::SingularPtrField<NetworkServer>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CreateNetworkServerRequest {
    fn default() -> &'a CreateNetworkServerRequest {
        <CreateNetworkServerRequest as ::protobuf::Message>::default_instance()
    }
}

impl CreateNetworkServerRequest {
    pub fn new() -> CreateNetworkServerRequest {
        ::std::default::Default::default()
    }

    // .api.NetworkServer network_server = 1;


    pub fn get_network_server(&self) -> &NetworkServer {
        self.network_server.as_ref().unwrap_or_else(|| NetworkServer::default_instance())
    }
    pub fn clear_network_server(&mut self) {
        self.network_server.clear();
    }

    pub fn has_network_server(&self) -> bool {
        self.network_server.is_some()
    }

    // Param is passed by value, moved
    pub fn set_network_server(&mut self, v: NetworkServer) {
        self.network_server = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_network_server(&mut self) -> &mut NetworkServer {
        if self.network_server.is_none() {
            self.network_server.set_default();
        }
        self.network_server.as_mut().unwrap()
    }

    // Take field
    pub fn take_network_server(&mut self) -> NetworkServer {
        self.network_server.take().unwrap_or_else(|| NetworkServer::new())
    }
}

impl ::protobuf::Message for CreateNetworkServerRequest {
    fn is_initialized(&self) -> bool {
        for v in &self.network_server {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.network_server)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.network_server.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.network_server.as_ref() {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CreateNetworkServerRequest {
        CreateNetworkServerRequest::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<NetworkServer>>(
                    "network_server",
                    |m: &CreateNetworkServerRequest| { &m.network_server },
                    |m: &mut CreateNetworkServerRequest| { &mut m.network_server },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<CreateNetworkServerRequest>(
                    "CreateNetworkServerRequest",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static CreateNetworkServerRequest {
        static mut instance: ::protobuf::lazy::Lazy<CreateNetworkServerRequest> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const CreateNetworkServerRequest,
        };
        unsafe {
            instance.get(CreateNetworkServerRequest::new)
        }
    }
}

impl ::protobuf::Clear for CreateNetworkServerRequest {
    fn clear(&mut self) {
        self.network_server.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CreateNetworkServerRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CreateNetworkServerRequest {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CreateNetworkServerResponse {
    // message fields
    pub id: i64,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CreateNetworkServerResponse {
    fn default() -> &'a CreateNetworkServerResponse {
        <CreateNetworkServerResponse as ::protobuf::Message>::default_instance()
    }
}

impl CreateNetworkServerResponse {
    pub fn new() -> CreateNetworkServerResponse {
        ::std::default::Default::default()
    }

    // int64 id = 1;


    pub fn get_id(&self) -> i64 {
        self.id
    }
    pub fn clear_id(&mut self) {
        self.id = 0;
    }

    // Param is passed by value, moved
    pub fn set_id(&mut self, v: i64) {
        self.id = v;
    }
}

impl ::protobuf::Message for CreateNetworkServerResponse {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.id = tmp;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.id != 0 {
            my_size += ::protobuf::rt::value_size(1, self.id, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if self.id != 0 {
            os.write_int64(1, self.id)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CreateNetworkServerResponse {
        CreateNetworkServerResponse::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "id",
                    |m: &CreateNetworkServerResponse| { &m.id },
                    |m: &mut CreateNetworkServerResponse| { &mut m.id },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<CreateNetworkServerResponse>(
                    "CreateNetworkServerResponse",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static CreateNetworkServerResponse {
        static mut instance: ::protobuf::lazy::Lazy<CreateNetworkServerResponse> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const CreateNetworkServerResponse,
        };
        unsafe {
            instance.get(CreateNetworkServerResponse::new)
        }
    }
}

impl ::protobuf::Clear for CreateNetworkServerResponse {
    fn clear(&mut self) {
        self.id = 0;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CreateNetworkServerResponse {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CreateNetworkServerResponse {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct GetNetworkServerRequest {
    // message fields
    pub id: i64,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a GetNetworkServerRequest {
    fn default() -> &'a GetNetworkServerRequest {
        <GetNetworkServerRequest as ::protobuf::Message>::default_instance()
    }
}

impl GetNetworkServerRequest {
    pub fn new() -> GetNetworkServerRequest {
        ::std::default::Default::default()
    }

    // int64 id = 1;


    pub fn get_id(&self) -> i64 {
        self.id
    }
    pub fn clear_id(&mut self) {
        self.id = 0;
    }

    // Param is passed by value, moved
    pub fn set_id(&mut self, v: i64) {
        self.id = v;
    }
}

impl ::protobuf::Message for GetNetworkServerRequest {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.id = tmp;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.id != 0 {
            my_size += ::protobuf::rt::value_size(1, self.id, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if self.id != 0 {
            os.write_int64(1, self.id)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> GetNetworkServerRequest {
        GetNetworkServerRequest::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "id",
                    |m: &GetNetworkServerRequest| { &m.id },
                    |m: &mut GetNetworkServerRequest| { &mut m.id },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<GetNetworkServerRequest>(
                    "GetNetworkServerRequest",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static GetNetworkServerRequest {
        static mut instance: ::protobuf::lazy::Lazy<GetNetworkServerRequest> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const GetNetworkServerRequest,
        };
        unsafe {
            instance.get(GetNetworkServerRequest::new)
        }
    }
}

impl ::protobuf::Clear for GetNetworkServerRequest {
    fn clear(&mut self) {
        self.id = 0;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for GetNetworkServerRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for GetNetworkServerRequest {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct GetNetworkServerResponse {
    // message fields
    pub network_server: ::protobuf::SingularPtrField<NetworkServer>,
    pub created_at: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>,
    pub updated_at: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>,
    pub version: ::std::string::String,
    pub region: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a GetNetworkServerResponse {
    fn default() -> &'a GetNetworkServerResponse {
        <GetNetworkServerResponse as ::protobuf::Message>::default_instance()
    }
}

impl GetNetworkServerResponse {
    pub fn new() -> GetNetworkServerResponse {
        ::std::default::Default::default()
    }

    // .api.NetworkServer network_server = 1;


    pub fn get_network_server(&self) -> &NetworkServer {
        self.network_server.as_ref().unwrap_or_else(|| NetworkServer::default_instance())
    }
    pub fn clear_network_server(&mut self) {
        self.network_server.clear();
    }

    pub fn has_network_server(&self) -> bool {
        self.network_server.is_some()
    }

    // Param is passed by value, moved
    pub fn set_network_server(&mut self, v: NetworkServer) {
        self.network_server = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_network_server(&mut self) -> &mut NetworkServer {
        if self.network_server.is_none() {
            self.network_server.set_default();
        }
        self.network_server.as_mut().unwrap()
    }

    // Take field
    pub fn take_network_server(&mut self) -> NetworkServer {
        self.network_server.take().unwrap_or_else(|| NetworkServer::new())
    }

    // .google.protobuf.Timestamp created_at = 2;


    pub fn get_created_at(&self) -> &::protobuf::well_known_types::Timestamp {
        self.created_at.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::default_instance())
    }
    pub fn clear_created_at(&mut self) {
        self.created_at.clear();
    }

    pub fn has_created_at(&self) -> bool {
        self.created_at.is_some()
    }

    // Param is passed by value, moved
    pub fn set_created_at(&mut self, v: ::protobuf::well_known_types::Timestamp) {
        self.created_at = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_created_at(&mut self) -> &mut ::protobuf::well_known_types::Timestamp {
        if self.created_at.is_none() {
            self.created_at.set_default();
        }
        self.created_at.as_mut().unwrap()
    }

    // Take field
    pub fn take_created_at(&mut self) -> ::protobuf::well_known_types::Timestamp {
        self.created_at.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new())
    }

    // .google.protobuf.Timestamp updated_at = 3;


    pub fn get_updated_at(&self) -> &::protobuf::well_known_types::Timestamp {
        self.updated_at.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::default_instance())
    }
    pub fn clear_updated_at(&mut self) {
        self.updated_at.clear();
    }

    pub fn has_updated_at(&self) -> bool {
        self.updated_at.is_some()
    }

    // Param is passed by value, moved
    pub fn set_updated_at(&mut self, v: ::protobuf::well_known_types::Timestamp) {
        self.updated_at = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_updated_at(&mut self) -> &mut ::protobuf::well_known_types::Timestamp {
        if self.updated_at.is_none() {
            self.updated_at.set_default();
        }
        self.updated_at.as_mut().unwrap()
    }

    // Take field
    pub fn take_updated_at(&mut self) -> ::protobuf::well_known_types::Timestamp {
        self.updated_at.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new())
    }

    // string version = 4;


    pub fn get_version(&self) -> &str {
        &self.version
    }
    pub fn clear_version(&mut self) {
        self.version.clear();
    }

    // Param is passed by value, moved
    pub fn set_version(&mut self, v: ::std::string::String) {
        self.version = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_version(&mut self) -> &mut ::std::string::String {
        &mut self.version
    }

    // Take field
    pub fn take_version(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.version, ::std::string::String::new())
    }

    // string region = 5;


    pub fn get_region(&self) -> &str {
        &self.region
    }
    pub fn clear_region(&mut self) {
        self.region.clear();
    }

    // Param is passed by value, moved
    pub fn set_region(&mut self, v: ::std::string::String) {
        self.region = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_region(&mut self) -> &mut ::std::string::String {
        &mut self.region
    }

    // Take field
    pub fn take_region(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.region, ::std::string::String::new())
    }
}

impl ::protobuf::Message for GetNetworkServerResponse {
    fn is_initialized(&self) -> bool {
        for v in &self.network_server {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.created_at {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.updated_at {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.network_server)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.created_at)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.updated_at)?;
                },
                4 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.version)?;
                },
                5 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.region)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.network_server.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.created_at.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.updated_at.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if !self.version.is_empty() {
            my_size += ::protobuf::rt::string_size(4, &self.version);
        }
        if !self.region.is_empty() {
            my_size += ::protobuf::rt::string_size(5, &self.region);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.network_server.as_ref() {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.created_at.as_ref() {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.updated_at.as_ref() {
            os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if !self.version.is_empty() {
            os.write_string(4, &self.version)?;
        }
        if !self.region.is_empty() {
            os.write_string(5, &self.region)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> GetNetworkServerResponse {
        GetNetworkServerResponse::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<NetworkServer>>(
                    "network_server",
                    |m: &GetNetworkServerResponse| { &m.network_server },
                    |m: &mut GetNetworkServerResponse| { &mut m.network_server },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>(
                    "created_at",
                    |m: &GetNetworkServerResponse| { &m.created_at },
                    |m: &mut GetNetworkServerResponse| { &mut m.created_at },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>(
                    "updated_at",
                    |m: &GetNetworkServerResponse| { &m.updated_at },
                    |m: &mut GetNetworkServerResponse| { &mut m.updated_at },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "version",
                    |m: &GetNetworkServerResponse| { &m.version },
                    |m: &mut GetNetworkServerResponse| { &mut m.version },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "region",
                    |m: &GetNetworkServerResponse| { &m.region },
                    |m: &mut GetNetworkServerResponse| { &mut m.region },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<GetNetworkServerResponse>(
                    "GetNetworkServerResponse",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static GetNetworkServerResponse {
        static mut instance: ::protobuf::lazy::Lazy<GetNetworkServerResponse> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const GetNetworkServerResponse,
        };
        unsafe {
            instance.get(GetNetworkServerResponse::new)
        }
    }
}

impl ::protobuf::Clear for GetNetworkServerResponse {
    fn clear(&mut self) {
        self.network_server.clear();
        self.created_at.clear();
        self.updated_at.clear();
        self.version.clear();
        self.region.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for GetNetworkServerResponse {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for GetNetworkServerResponse {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct UpdateNetworkServerRequest {
    // message fields
    pub network_server: ::protobuf::SingularPtrField<NetworkServer>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a UpdateNetworkServerRequest {
    fn default() -> &'a UpdateNetworkServerRequest {
        <UpdateNetworkServerRequest as ::protobuf::Message>::default_instance()
    }
}

impl UpdateNetworkServerRequest {
    pub fn new() -> UpdateNetworkServerRequest {
        ::std::default::Default::default()
    }

    // .api.NetworkServer network_server = 1;


    pub fn get_network_server(&self) -> &NetworkServer {
        self.network_server.as_ref().unwrap_or_else(|| NetworkServer::default_instance())
    }
    pub fn clear_network_server(&mut self) {
        self.network_server.clear();
    }

    pub fn has_network_server(&self) -> bool {
        self.network_server.is_some()
    }

    // Param is passed by value, moved
    pub fn set_network_server(&mut self, v: NetworkServer) {
        self.network_server = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_network_server(&mut self) -> &mut NetworkServer {
        if self.network_server.is_none() {
            self.network_server.set_default();
        }
        self.network_server.as_mut().unwrap()
    }

    // Take field
    pub fn take_network_server(&mut self) -> NetworkServer {
        self.network_server.take().unwrap_or_else(|| NetworkServer::new())
    }
}

impl ::protobuf::Message for UpdateNetworkServerRequest {
    fn is_initialized(&self) -> bool {
        for v in &self.network_server {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.network_server)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.network_server.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.network_server.as_ref() {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> UpdateNetworkServerRequest {
        UpdateNetworkServerRequest::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<NetworkServer>>(
                    "network_server",
                    |m: &UpdateNetworkServerRequest| { &m.network_server },
                    |m: &mut UpdateNetworkServerRequest| { &mut m.network_server },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<UpdateNetworkServerRequest>(
                    "UpdateNetworkServerRequest",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static UpdateNetworkServerRequest {
        static mut instance: ::protobuf::lazy::Lazy<UpdateNetworkServerRequest> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const UpdateNetworkServerRequest,
        };
        unsafe {
            instance.get(UpdateNetworkServerRequest::new)
        }
    }
}

impl ::protobuf::Clear for UpdateNetworkServerRequest {
    fn clear(&mut self) {
        self.network_server.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for UpdateNetworkServerRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for UpdateNetworkServerRequest {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct DeleteNetworkServerRequest {
    // message fields
    pub id: i64,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a DeleteNetworkServerRequest {
    fn default() -> &'a DeleteNetworkServerRequest {
        <DeleteNetworkServerRequest as ::protobuf::Message>::default_instance()
    }
}

impl DeleteNetworkServerRequest {
    pub fn new() -> DeleteNetworkServerRequest {
        ::std::default::Default::default()
    }

    // int64 id = 1;


    pub fn get_id(&self) -> i64 {
        self.id
    }
    pub fn clear_id(&mut self) {
        self.id = 0;
    }

    // Param is passed by value, moved
    pub fn set_id(&mut self, v: i64) {
        self.id = v;
    }
}

impl ::protobuf::Message for DeleteNetworkServerRequest {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.id = tmp;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.id != 0 {
            my_size += ::protobuf::rt::value_size(1, self.id, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if self.id != 0 {
            os.write_int64(1, self.id)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> DeleteNetworkServerRequest {
        DeleteNetworkServerRequest::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "id",
                    |m: &DeleteNetworkServerRequest| { &m.id },
                    |m: &mut DeleteNetworkServerRequest| { &mut m.id },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<DeleteNetworkServerRequest>(
                    "DeleteNetworkServerRequest",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static DeleteNetworkServerRequest {
        static mut instance: ::protobuf::lazy::Lazy<DeleteNetworkServerRequest> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const DeleteNetworkServerRequest,
        };
        unsafe {
            instance.get(DeleteNetworkServerRequest::new)
        }
    }
}

impl ::protobuf::Clear for DeleteNetworkServerRequest {
    fn clear(&mut self) {
        self.id = 0;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for DeleteNetworkServerRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for DeleteNetworkServerRequest {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct ListNetworkServerRequest {
    // message fields
    pub limit: i64,
    pub offset: i64,
    pub organization_id: i64,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a ListNetworkServerRequest {
    fn default() -> &'a ListNetworkServerRequest {
        <ListNetworkServerRequest as ::protobuf::Message>::default_instance()
    }
}

impl ListNetworkServerRequest {
    pub fn new() -> ListNetworkServerRequest {
        ::std::default::Default::default()
    }

    // int64 limit = 1;


    pub fn get_limit(&self) -> i64 {
        self.limit
    }
    pub fn clear_limit(&mut self) {
        self.limit = 0;
    }

    // Param is passed by value, moved
    pub fn set_limit(&mut self, v: i64) {
        self.limit = v;
    }

    // int64 offset = 2;


    pub fn get_offset(&self) -> i64 {
        self.offset
    }
    pub fn clear_offset(&mut self) {
        self.offset = 0;
    }

    // Param is passed by value, moved
    pub fn set_offset(&mut self, v: i64) {
        self.offset = v;
    }

    // int64 organization_id = 3;


    pub fn get_organization_id(&self) -> i64 {
        self.organization_id
    }
    pub fn clear_organization_id(&mut self) {
        self.organization_id = 0;
    }

    // Param is passed by value, moved
    pub fn set_organization_id(&mut self, v: i64) {
        self.organization_id = v;
    }
}

impl ::protobuf::Message for ListNetworkServerRequest {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.limit = tmp;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.offset = tmp;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.organization_id = tmp;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.limit != 0 {
            my_size += ::protobuf::rt::value_size(1, self.limit, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.offset != 0 {
            my_size += ::protobuf::rt::value_size(2, self.offset, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.organization_id != 0 {
            my_size += ::protobuf::rt::value_size(3, self.organization_id, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if self.limit != 0 {
            os.write_int64(1, self.limit)?;
        }
        if self.offset != 0 {
            os.write_int64(2, self.offset)?;
        }
        if self.organization_id != 0 {
            os.write_int64(3, self.organization_id)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> ListNetworkServerRequest {
        ListNetworkServerRequest::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "limit",
                    |m: &ListNetworkServerRequest| { &m.limit },
                    |m: &mut ListNetworkServerRequest| { &mut m.limit },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "offset",
                    |m: &ListNetworkServerRequest| { &m.offset },
                    |m: &mut ListNetworkServerRequest| { &mut m.offset },
                ));
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "organization_id",
                    |m: &ListNetworkServerRequest| { &m.organization_id },
                    |m: &mut ListNetworkServerRequest| { &mut m.organization_id },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<ListNetworkServerRequest>(
                    "ListNetworkServerRequest",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static ListNetworkServerRequest {
        static mut instance: ::protobuf::lazy::Lazy<ListNetworkServerRequest> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ListNetworkServerRequest,
        };
        unsafe {
            instance.get(ListNetworkServerRequest::new)
        }
    }
}

impl ::protobuf::Clear for ListNetworkServerRequest {
    fn clear(&mut self) {
        self.limit = 0;
        self.offset = 0;
        self.organization_id = 0;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for ListNetworkServerRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for ListNetworkServerRequest {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct ListNetworkServerResponse {
    // message fields
    pub total_count: i64,
    pub result: ::protobuf::RepeatedField<NetworkServerListItem>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a ListNetworkServerResponse {
    fn default() -> &'a ListNetworkServerResponse {
        <ListNetworkServerResponse as ::protobuf::Message>::default_instance()
    }
}

impl ListNetworkServerResponse {
    pub fn new() -> ListNetworkServerResponse {
        ::std::default::Default::default()
    }

    // int64 total_count = 1;


    pub fn get_total_count(&self) -> i64 {
        self.total_count
    }
    pub fn clear_total_count(&mut self) {
        self.total_count = 0;
    }

    // Param is passed by value, moved
    pub fn set_total_count(&mut self, v: i64) {
        self.total_count = v;
    }

    // repeated .api.NetworkServerListItem result = 2;


    pub fn get_result(&self) -> &[NetworkServerListItem] {
        &self.result
    }
    pub fn clear_result(&mut self) {
        self.result.clear();
    }

    // Param is passed by value, moved
    pub fn set_result(&mut self, v: ::protobuf::RepeatedField<NetworkServerListItem>) {
        self.result = v;
    }

    // Mutable pointer to the field.
    pub fn mut_result(&mut self) -> &mut ::protobuf::RepeatedField<NetworkServerListItem> {
        &mut self.result
    }

    // Take field
    pub fn take_result(&mut self) -> ::protobuf::RepeatedField<NetworkServerListItem> {
        ::std::mem::replace(&mut self.result, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for ListNetworkServerResponse {
    fn is_initialized(&self) -> bool {
        for v in &self.result {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.total_count = tmp;
                },
                2 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.result)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.total_count != 0 {
            my_size += ::protobuf::rt::value_size(1, self.total_count, ::protobuf::wire_format::WireTypeVarint);
        }
        for value in &self.result {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if self.total_count != 0 {
            os.write_int64(1, self.total_count)?;
        }
        for v in &self.result {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> ListNetworkServerResponse {
        ListNetworkServerResponse::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                    "total_count",
                    |m: &ListNetworkServerResponse| { &m.total_count },
                    |m: &mut ListNetworkServerResponse| { &mut m.total_count },
                ));
                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<NetworkServerListItem>>(
                    "result",
                    |m: &ListNetworkServerResponse| { &m.result },
                    |m: &mut ListNetworkServerResponse| { &mut m.result },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<ListNetworkServerResponse>(
                    "ListNetworkServerResponse",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static ListNetworkServerResponse {
        static mut instance: ::protobuf::lazy::Lazy<ListNetworkServerResponse> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ListNetworkServerResponse,
        };
        unsafe {
            instance.get(ListNetworkServerResponse::new)
        }
    }
}

impl ::protobuf::Clear for ListNetworkServerResponse {
    fn clear(&mut self) {
        self.total_count = 0;
        self.result.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for ListNetworkServerResponse {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for ListNetworkServerResponse {
    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

static file_descriptor_proto_data: &'static [u8] = b"\
    \n#as/external/api/networkServer.proto\x12\x03api\x1a\x1cgoogle/api/anno\
    tations.proto\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x1bgoogle/proto\
    buf/empty.proto\"\xb0\x04\n\rNetworkServer\x12\x0e\n\x02id\x18\x01\x20\
    \x01(\x03R\x02id\x12\x12\n\x04name\x18\x02\x20\x01(\tR\x04name\x12\x16\n\
    \x06server\x18\x03\x20\x01(\tR\x06server\x12\x17\n\x07ca_cert\x18\x04\
    \x20\x01(\tR\x06caCert\x12\x19\n\x08tls_cert\x18\x05\x20\x01(\tR\x07tlsC\
    ert\x12\x17\n\x07tls_key\x18\x06\x20\x01(\tR\x06tlsKey\x125\n\x17routing\
    _profile_ca_cert\x18\x07\x20\x01(\tR\x14routingProfileCACert\x127\n\x18r\
    outing_profile_tls_cert\x18\x08\x20\x01(\tR\x15routingProfileTLSCert\x12\
    5\n\x17routing_profile_tls_key\x18\t\x20\x01(\tR\x14routingProfileTLSKey\
    \x12:\n\x19gateway_discovery_enabled\x18\n\x20\x01(\x08R\x17gatewayDisco\
    veryEnabled\x12<\n\x1agateway_discovery_interval\x18\x0b\x20\x01(\rR\x18\
    gatewayDiscoveryInterval\x12C\n\x1egateway_discovery_tx_frequency\x18\
    \x0c\x20\x01(\rR\x1bgatewayDiscoveryTXFrequency\x120\n\x14gateway_discov\
    ery_dr\x18\r\x20\x01(\rR\x12gatewayDiscoveryDR\"\xc9\x01\n\x15NetworkSer\
    verListItem\x12\x0e\n\x02id\x18\x01\x20\x01(\x03R\x02id\x12\x12\n\x04nam\
    e\x18\x02\x20\x01(\tR\x04name\x12\x16\n\x06server\x18\x03\x20\x01(\tR\
    \x06server\x129\n\ncreated_at\x18\x04\x20\x01(\x0b2\x1a.google.protobuf.\
    TimestampR\tcreatedAt\x129\n\nupdated_at\x18\x05\x20\x01(\x0b2\x1a.googl\
    e.protobuf.TimestampR\tupdatedAt\"W\n\x1aCreateNetworkServerRequest\x129\
    \n\x0enetwork_server\x18\x01\x20\x01(\x0b2\x12.api.NetworkServerR\rnetwo\
    rkServer\"-\n\x1bCreateNetworkServerResponse\x12\x0e\n\x02id\x18\x01\x20\
    \x01(\x03R\x02id\")\n\x17GetNetworkServerRequest\x12\x0e\n\x02id\x18\x01\
    \x20\x01(\x03R\x02id\"\xfd\x01\n\x18GetNetworkServerResponse\x129\n\x0en\
    etwork_server\x18\x01\x20\x01(\x0b2\x12.api.NetworkServerR\rnetworkServe\
    r\x129\n\ncreated_at\x18\x02\x20\x01(\x0b2\x1a.google.protobuf.Timestamp\
    R\tcreatedAt\x129\n\nupdated_at\x18\x03\x20\x01(\x0b2\x1a.google.protobu\
    f.TimestampR\tupdatedAt\x12\x18\n\x07version\x18\x04\x20\x01(\tR\x07vers\
    ion\x12\x16\n\x06region\x18\x05\x20\x01(\tR\x06region\"W\n\x1aUpdateNetw\
    orkServerRequest\x129\n\x0enetwork_server\x18\x01\x20\x01(\x0b2\x12.api.\
    NetworkServerR\rnetworkServer\",\n\x1aDeleteNetworkServerRequest\x12\x0e\
    \n\x02id\x18\x01\x20\x01(\x03R\x02id\"q\n\x18ListNetworkServerRequest\
    \x12\x14\n\x05limit\x18\x01\x20\x01(\x03R\x05limit\x12\x16\n\x06offset\
    \x18\x02\x20\x01(\x03R\x06offset\x12'\n\x0forganization_id\x18\x03\x20\
    \x01(\x03R\x0eorganizationID\"p\n\x19ListNetworkServerResponse\x12\x1f\n\
    \x0btotal_count\x18\x01\x20\x01(\x03R\ntotalCount\x122\n\x06result\x18\
    \x02\x20\x03(\x0b2\x1a.api.NetworkServerListItemR\x06result2\xae\x04\n\
    \x14NetworkServerService\x12l\n\x06Create\x12\x1f.api.CreateNetworkServe\
    rRequest\x1a\x20.api.CreateNetworkServerResponse\"\x1f\x82\xd3\xe4\x93\
    \x02\x19\"\x14/api/network-servers:\x01*\x12e\n\x03Get\x12\x1c.api.GetNe\
    tworkServerRequest\x1a\x1d.api.GetNetworkServerResponse\"!\x82\xd3\xe4\
    \x93\x02\x1b\x12\x19/api/network-servers/{id}\x12v\n\x06Update\x12\x1f.a\
    pi.UpdateNetworkServerRequest\x1a\x16.google.protobuf.Empty\"3\x82\xd3\
    \xe4\x93\x02-\x1a(/api/network-servers/{network_server.id}:\x01*\x12d\n\
    \x06Delete\x12\x1f.api.DeleteNetworkServerRequest\x1a\x16.google.protobu\
    f.Empty\"!\x82\xd3\xe4\x93\x02\x1b*\x19/api/network-servers/{id}\x12c\n\
    \x04List\x12\x1d.api.ListNetworkServerRequest\x1a\x1e.api.ListNetworkSer\
    verResponse\"\x1c\x82\xd3\xe4\x93\x02\x16\x12\x14/api/network-serversB9Z\
    7github.com/brocaar/chirpstack-api/go/v3/as/external/apiJ\xf7(\n\x07\x12\
    \x05\0\0\xae\x01\x01\n\x08\n\x01\x0c\x12\x03\0\0\x12\n\x08\n\x01\x02\x12\
    \x03\x02\x08\x0b\n\x08\n\x01\x08\x12\x03\x04\0N\n\t\n\x02\x08\x0b\x12\
    \x03\x04\0N\n\t\n\x02\x03\0\x12\x03\x06\x07%\n\t\n\x02\x03\x01\x12\x03\
    \x07\x07(\n\t\n\x02\x03\x02\x12\x03\x08\x07$\nK\n\x02\x06\0\x12\x04\x0c\
    \01\x01\x1a?\x20NetworkServerService\x20is\x20the\x20service\x20managing\
    \x20network-servers.\n\n\n\n\x03\x06\0\x01\x12\x03\x0c\x08\x1c\n8\n\x04\
    \x06\0\x02\0\x12\x04\x0e\x04\x13\x05\x1a*\x20Create\x20creates\x20the\
    \x20given\x20network-server.\n\n\x0c\n\x05\x06\0\x02\0\x01\x12\x03\x0e\
    \x08\x0e\n\x0c\n\x05\x06\0\x02\0\x02\x12\x03\x0e\x0f)\n\x0c\n\x05\x06\0\
    \x02\0\x03\x12\x03\x0e4O\n\r\n\x05\x06\0\x02\0\x04\x12\x04\x0f\x08\x12\n\
    \n\x11\n\t\x06\0\x02\0\x04\xb0\xca\xbc\"\x12\x04\x0f\x08\x12\n\nE\n\x04\
    \x06\0\x02\x01\x12\x04\x16\x04\x1a\x05\x1a7\x20Get\x20returns\x20the\x20\
    network-server\x20matching\x20the\x20given\x20id.\n\n\x0c\n\x05\x06\0\
    \x02\x01\x01\x12\x03\x16\x08\x0b\n\x0c\n\x05\x06\0\x02\x01\x02\x12\x03\
    \x16\x0c#\n\x0c\n\x05\x06\0\x02\x01\x03\x12\x03\x16.F\n\r\n\x05\x06\0\
    \x02\x01\x04\x12\x04\x17\x08\x19\n\n\x11\n\t\x06\0\x02\x01\x04\xb0\xca\
    \xbc\"\x12\x04\x17\x08\x19\n\n8\n\x04\x06\0\x02\x02\x12\x04\x1d\x04\"\
    \x05\x1a*\x20Update\x20updates\x20the\x20given\x20network-server.\n\n\
    \x0c\n\x05\x06\0\x02\x02\x01\x12\x03\x1d\x08\x0e\n\x0c\n\x05\x06\0\x02\
    \x02\x02\x12\x03\x1d\x0f)\n\x0c\n\x05\x06\0\x02\x02\x03\x12\x03\x1d4I\n\
    \r\n\x05\x06\0\x02\x02\x04\x12\x04\x1e\x08!\n\n\x11\n\t\x06\0\x02\x02\
    \x04\xb0\xca\xbc\"\x12\x04\x1e\x08!\n\nH\n\x04\x06\0\x02\x03\x12\x04%\
    \x04)\x05\x1a:\x20Delete\x20deletes\x20the\x20network-server\x20matching\
    \x20the\x20given\x20id.\n\n\x0c\n\x05\x06\0\x02\x03\x01\x12\x03%\x08\x0e\
    \n\x0c\n\x05\x06\0\x02\x03\x02\x12\x03%\x0f)\n\x0c\n\x05\x06\0\x02\x03\
    \x03\x12\x03%4I\n\r\n\x05\x06\0\x02\x03\x04\x12\x04&\x08(\n\n\x11\n\t\
    \x06\0\x02\x03\x04\xb0\xca\xbc\"\x12\x04&\x08(\n\n9\n\x04\x06\0\x02\x04\
    \x12\x04,\x040\x05\x1a+\x20List\x20lists\x20the\x20available\x20network-\
    servers.\n\n\x0c\n\x05\x06\0\x02\x04\x01\x12\x03,\x08\x0c\n\x0c\n\x05\
    \x06\0\x02\x04\x02\x12\x03,\r%\n\x0c\n\x05\x06\0\x02\x04\x03\x12\x03,0I\
    \n\r\n\x05\x06\0\x02\x04\x04\x12\x04-\x08/\n\n\x11\n\t\x06\0\x02\x04\x04\
    \xb0\xca\xbc\"\x12\x04-\x08/\n\n\n\n\x02\x04\0\x12\x043\0_\x01\n\n\n\x03\
    \x04\0\x01\x12\x033\x08\x15\n!\n\x04\x04\0\x02\0\x12\x035\x04\x11\x1a\
    \x14\x20Network-server\x20ID.\n\n\r\n\x05\x04\0\x02\0\x04\x12\x045\x043\
    \x17\n\x0c\n\x05\x04\0\x02\0\x05\x12\x035\x04\t\n\x0c\n\x05\x04\0\x02\0\
    \x01\x12\x035\n\x0c\n\x0c\n\x05\x04\0\x02\0\x03\x12\x035\x0f\x10\n#\n\
    \x04\x04\0\x02\x01\x12\x038\x04\x14\x1a\x16\x20Network-server\x20name.\n\
    \n\r\n\x05\x04\0\x02\x01\x04\x12\x048\x045\x11\n\x0c\n\x05\x04\0\x02\x01\
    \x05\x12\x038\x04\n\n\x0c\n\x05\x04\0\x02\x01\x01\x12\x038\x0b\x0f\n\x0c\
    \n\x05\x04\0\x02\x01\x03\x12\x038\x12\x13\nQ\n\x04\x04\0\x02\x02\x12\x03\
    <\x04\x16\x1aD\x20Network-server\x20server.\n\x20Format:\x20hostname:ip\
    \x20(e.g.\x20localhost:8000).\n\n\r\n\x05\x04\0\x02\x02\x04\x12\x04<\x04\
    8\x14\n\x0c\n\x05\x04\0\x02\x02\x05\x12\x03<\x04\n\n\x0c\n\x05\x04\0\x02\
    \x02\x01\x12\x03<\x0b\x11\n\x0c\n\x05\x04\0\x02\x02\x03\x12\x03<\x14\x15\
    \n)\n\x04\x04\0\x02\x03\x12\x03?\x04\x17\x1a\x1c\x20CA\x20certificate\
    \x20(optional).\n\n\r\n\x05\x04\0\x02\x03\x04\x12\x04?\x04<\x16\n\x0c\n\
    \x05\x04\0\x02\x03\x05\x12\x03?\x04\n\n\x0c\n\x05\x04\0\x02\x03\x01\x12\
    \x03?\x0b\x12\n\x0c\n\x05\x04\0\x02\x03\x03\x12\x03?\x15\x16\nX\n\x04\
    \x04\0\x02\x04\x12\x03B\x04\x18\x1aK\x20TLS\x20(client)\x20certificate\
    \x20for\x20connecting\x20to\x20the\x20network-server\x20(optional).\n\n\
    \r\n\x05\x04\0\x02\x04\x04\x12\x04B\x04?\x17\n\x0c\n\x05\x04\0\x02\x04\
    \x05\x12\x03B\x04\n\n\x0c\n\x05\x04\0\x02\x04\x01\x12\x03B\x0b\x13\n\x0c\
    \n\x05\x04\0\x02\x04\x03\x12\x03B\x16\x17\nP\n\x04\x04\0\x02\x05\x12\x03\
    E\x04\x17\x1aC\x20TLS\x20(client)\x20key\x20for\x20connecting\x20to\x20t\
    he\x20network-server\x20(optional).\n\n\r\n\x05\x04\0\x02\x05\x04\x12\
    \x04E\x04B\x18\n\x0c\n\x05\x04\0\x02\x05\x05\x12\x03E\x04\n\n\x0c\n\x05\
    \x04\0\x02\x05\x01\x12\x03E\x0b\x12\n\x0c\n\x05\x04\0\x02\x05\x03\x12\
    \x03E\x15\x16\n\x81\x01\n\x04\x04\0\x02\x06\x12\x03I\x04L\x1at\x20Routin\
    g-profile\x20ca\x20certificate\x20(used\x20by\x20the\x20network-server\
    \x20to\x20connect\n\x20back\x20to\x20the\x20application-server)\x20(opti\
    onal).\n\n\r\n\x05\x04\0\x02\x06\x04\x12\x04I\x04E\x17\n\x0c\n\x05\x04\0\
    \x02\x06\x05\x12\x03I\x04\n\n\x0c\n\x05\x04\0\x02\x06\x01\x12\x03I\x0b\"\
    \n\x0c\n\x05\x04\0\x02\x06\x03\x12\x03I%&\n\x0c\n\x05\x04\0\x02\x06\x08\
    \x12\x03I'K\n\x0c\n\x05\x04\0\x02\x06\n\x12\x03I4J\n\x82\x01\n\x04\x04\0\
    \x02\x07\x12\x03M\x04N\x1au\x20Routing-profile\x20TLS\x20certificate\x20\
    (used\x20by\x20the\x20network-server\x20to\x20connect\n\x20back\x20to\
    \x20the\x20application-server)\x20(optional).\n\n\r\n\x05\x04\0\x02\x07\
    \x04\x12\x04M\x04IL\n\x0c\n\x05\x04\0\x02\x07\x05\x12\x03M\x04\n\n\x0c\n\
    \x05\x04\0\x02\x07\x01\x12\x03M\x0b#\n\x0c\n\x05\x04\0\x02\x07\x03\x12\
    \x03M&'\n\x0c\n\x05\x04\0\x02\x07\x08\x12\x03M(M\n\x0c\n\x05\x04\0\x02\
    \x07\n\x12\x03M5L\nz\n\x04\x04\0\x02\x08\x12\x03Q\x04L\x1am\x20Routing-p\
    rofile\x20TLS\x20key\x20(used\x20by\x20the\x20network-server\x20to\x20co\
    nnect\n\x20back\x20to\x20the\x20application-server)\x20(optional).\n\n\r\
    \n\x05\x04\0\x02\x08\x04\x12\x04Q\x04MN\n\x0c\n\x05\x04\0\x02\x08\x05\
    \x12\x03Q\x04\n\n\x0c\n\x05\x04\0\x02\x08\x01\x12\x03Q\x0b\"\n\x0c\n\x05\
    \x04\0\x02\x08\x03\x12\x03Q%&\n\x0c\n\x05\x04\0\x02\x08\x08\x12\x03Q'K\n\
    \x0c\n\x05\x04\0\x02\x08\n\x12\x03Q4J\n@\n\x04\x04\0\x02\t\x12\x03T\x04(\
    \x1a3\x20Enable\x20gateway\x20discovery\x20for\x20this\x20network-server\
    .\n\n\r\n\x05\x04\0\x02\t\x04\x12\x04T\x04QL\n\x0c\n\x05\x04\0\x02\t\x05\
    \x12\x03T\x04\x08\n\x0c\n\x05\x04\0\x02\t\x01\x12\x03T\t\"\n\x0c\n\x05\
    \x04\0\x02\t\x03\x12\x03T%'\ni\n\x04\x04\0\x02\n\x12\x03X\x04+\x1a\\\x20\
    The\x20number\x20of\x20times\x20per\x20day\x20the\x20gateway\x20discover\
    y\x20'ping'\x20must\x20be\n\x20broadcasted\x20per\x20gateway.\n\n\r\n\
    \x05\x04\0\x02\n\x04\x12\x04X\x04T(\n\x0c\n\x05\x04\0\x02\n\x05\x12\x03X\
    \x04\n\n\x0c\n\x05\x04\0\x02\n\x01\x12\x03X\x0b%\n\x0c\n\x05\x04\0\x02\n\
    \x03\x12\x03X(*\nB\n\x04\x04\0\x02\x0b\x12\x03[\x04[\x1a5\x20The\x20freq\
    uency\x20(Hz)\x20of\x20the\x20gateway\x20discovery\x20'ping'.\n\n\r\n\
    \x05\x04\0\x02\x0b\x04\x12\x04[\x04X+\n\x0c\n\x05\x04\0\x02\x0b\x05\x12\
    \x03[\x04\n\n\x0c\n\x05\x04\0\x02\x0b\x01\x12\x03[\x0b)\n\x0c\n\x05\x04\
    \0\x02\x0b\x03\x12\x03[,.\n\x0c\n\x05\x04\0\x02\x0b\x08\x12\x03[/Z\n\x0c\
    \n\x05\x04\0\x02\x0b\n\x12\x03[<Y\n=\n\x04\x04\0\x02\x0c\x12\x03^\x04H\
    \x1a0\x20The\x20data-rate\x20of\x20the\x20gateway\x20discovery\x20'ping'\
    .\n\n\r\n\x05\x04\0\x02\x0c\x04\x12\x04^\x04[[\n\x0c\n\x05\x04\0\x02\x0c\
    \x05\x12\x03^\x04\n\n\x0c\n\x05\x04\0\x02\x0c\x01\x12\x03^\x0b\x1f\n\x0c\
    \n\x05\x04\0\x02\x0c\x03\x12\x03^\"$\n\x0c\n\x05\x04\0\x02\x0c\x08\x12\
    \x03^%G\n\x0c\n\x05\x04\0\x02\x0c\n\x12\x03^2F\n\n\n\x02\x04\x01\x12\x04\
    a\0q\x01\n\n\n\x03\x04\x01\x01\x12\x03a\x08\x1d\n!\n\x04\x04\x01\x02\0\
    \x12\x03c\x04\x11\x1a\x14\x20Network-server\x20ID.\n\n\r\n\x05\x04\x01\
    \x02\0\x04\x12\x04c\x04a\x1f\n\x0c\n\x05\x04\x01\x02\0\x05\x12\x03c\x04\
    \t\n\x0c\n\x05\x04\x01\x02\0\x01\x12\x03c\n\x0c\n\x0c\n\x05\x04\x01\x02\
    \0\x03\x12\x03c\x0f\x10\n#\n\x04\x04\x01\x02\x01\x12\x03f\x04\x14\x1a\
    \x16\x20Network-server\x20name.\n\n\r\n\x05\x04\x01\x02\x01\x04\x12\x04f\
    \x04c\x11\n\x0c\n\x05\x04\x01\x02\x01\x05\x12\x03f\x04\n\n\x0c\n\x05\x04\
    \x01\x02\x01\x01\x12\x03f\x0b\x0f\n\x0c\n\x05\x04\x01\x02\x01\x03\x12\
    \x03f\x12\x13\nQ\n\x04\x04\x01\x02\x02\x12\x03j\x04\x16\x1aD\x20Network-\
    server\x20server.\n\x20Format:\x20hostname:ip\x20(e.g.\x20localhost:8000\
    ).\n\n\r\n\x05\x04\x01\x02\x02\x04\x12\x04j\x04f\x14\n\x0c\n\x05\x04\x01\
    \x02\x02\x05\x12\x03j\x04\n\n\x0c\n\x05\x04\x01\x02\x02\x01\x12\x03j\x0b\
    \x11\n\x0c\n\x05\x04\x01\x02\x02\x03\x12\x03j\x14\x15\n$\n\x04\x04\x01\
    \x02\x03\x12\x03m\x04-\x1a\x17\x20Created\x20at\x20timestamp.\n\n\r\n\
    \x05\x04\x01\x02\x03\x04\x12\x04m\x04j\x16\n\x0c\n\x05\x04\x01\x02\x03\
    \x06\x12\x03m\x04\x1d\n\x0c\n\x05\x04\x01\x02\x03\x01\x12\x03m\x1e(\n\
    \x0c\n\x05\x04\x01\x02\x03\x03\x12\x03m+,\n%\n\x04\x04\x01\x02\x04\x12\
    \x03p\x04-\x1a\x18\x20Last\x20update\x20timestamp.\n\n\r\n\x05\x04\x01\
    \x02\x04\x04\x12\x04p\x04m-\n\x0c\n\x05\x04\x01\x02\x04\x06\x12\x03p\x04\
    \x1d\n\x0c\n\x05\x04\x01\x02\x04\x01\x12\x03p\x1e(\n\x0c\n\x05\x04\x01\
    \x02\x04\x03\x12\x03p+,\n\n\n\x02\x04\x02\x12\x04s\0v\x01\n\n\n\x03\x04\
    \x02\x01\x12\x03s\x08\"\n/\n\x04\x04\x02\x02\0\x12\x03u\x04%\x1a\"\x20Ne\
    twork-server\x20object\x20to\x20create.\n\n\r\n\x05\x04\x02\x02\0\x04\
    \x12\x04u\x04s$\n\x0c\n\x05\x04\x02\x02\0\x06\x12\x03u\x04\x11\n\x0c\n\
    \x05\x04\x02\x02\0\x01\x12\x03u\x12\x20\n\x0c\n\x05\x04\x02\x02\0\x03\
    \x12\x03u#$\n\n\n\x02\x04\x03\x12\x04x\0{\x01\n\n\n\x03\x04\x03\x01\x12\
    \x03x\x08#\n!\n\x04\x04\x03\x02\0\x12\x03z\x04\x11\x1a\x14\x20Network-se\
    rver\x20ID.\n\n\r\n\x05\x04\x03\x02\0\x04\x12\x04z\x04x%\n\x0c\n\x05\x04\
    \x03\x02\0\x05\x12\x03z\x04\t\n\x0c\n\x05\x04\x03\x02\0\x01\x12\x03z\n\
    \x0c\n\x0c\n\x05\x04\x03\x02\0\x03\x12\x03z\x0f\x10\n\x0b\n\x02\x04\x04\
    \x12\x05}\0\x80\x01\x01\n\n\n\x03\x04\x04\x01\x12\x03}\x08\x1f\n!\n\x04\
    \x04\x04\x02\0\x12\x03\x7f\x04\x11\x1a\x14\x20Network-server\x20ID.\n\n\
    \r\n\x05\x04\x04\x02\0\x04\x12\x04\x7f\x04}!\n\x0c\n\x05\x04\x04\x02\0\
    \x05\x12\x03\x7f\x04\t\n\x0c\n\x05\x04\x04\x02\0\x01\x12\x03\x7f\n\x0c\n\
    \x0c\n\x05\x04\x04\x02\0\x03\x12\x03\x7f\x0f\x10\n\x0c\n\x02\x04\x05\x12\
    \x06\x82\x01\0\x91\x01\x01\n\x0b\n\x03\x04\x05\x01\x12\x04\x82\x01\x08\
    \x20\n&\n\x04\x04\x05\x02\0\x12\x04\x84\x01\x04%\x1a\x18\x20Network-serv\
    er\x20object.\n\n\x0f\n\x05\x04\x05\x02\0\x04\x12\x06\x84\x01\x04\x82\
    \x01\"\n\r\n\x05\x04\x05\x02\0\x06\x12\x04\x84\x01\x04\x11\n\r\n\x05\x04\
    \x05\x02\0\x01\x12\x04\x84\x01\x12\x20\n\r\n\x05\x04\x05\x02\0\x03\x12\
    \x04\x84\x01#$\n%\n\x04\x04\x05\x02\x01\x12\x04\x87\x01\x04-\x1a\x17\x20\
    Created\x20at\x20timestamp.\n\n\x0f\n\x05\x04\x05\x02\x01\x04\x12\x06\
    \x87\x01\x04\x84\x01%\n\r\n\x05\x04\x05\x02\x01\x06\x12\x04\x87\x01\x04\
    \x1d\n\r\n\x05\x04\x05\x02\x01\x01\x12\x04\x87\x01\x1e(\n\r\n\x05\x04\
    \x05\x02\x01\x03\x12\x04\x87\x01+,\n&\n\x04\x04\x05\x02\x02\x12\x04\x8a\
    \x01\x04-\x1a\x18\x20Last\x20update\x20timestamp.\n\n\x0f\n\x05\x04\x05\
    \x02\x02\x04\x12\x06\x8a\x01\x04\x87\x01-\n\r\n\x05\x04\x05\x02\x02\x06\
    \x12\x04\x8a\x01\x04\x1d\n\r\n\x05\x04\x05\x02\x02\x01\x12\x04\x8a\x01\
    \x1e(\n\r\n\x05\x04\x05\x02\x02\x03\x12\x04\x8a\x01+,\n6\n\x04\x04\x05\
    \x02\x03\x12\x04\x8d\x01\x04\x17\x1a(\x20The\x20ChirpStack\x20Network\
    \x20Server\x20version.\n\n\x0f\n\x05\x04\x05\x02\x03\x04\x12\x06\x8d\x01\
    \x04\x8a\x01-\n\r\n\x05\x04\x05\x02\x03\x05\x12\x04\x8d\x01\x04\n\n\r\n\
    \x05\x04\x05\x02\x03\x01\x12\x04\x8d\x01\x0b\x12\n\r\n\x05\x04\x05\x02\
    \x03\x03\x12\x04\x8d\x01\x15\x16\n@\n\x04\x04\x05\x02\x04\x12\x04\x90\
    \x01\x04\x16\x1a2\x20The\x20ChirpStack\x20Network\x20Server\x20region\
    \x20configured.\n\n\x0f\n\x05\x04\x05\x02\x04\x04\x12\x06\x90\x01\x04\
    \x8d\x01\x17\n\r\n\x05\x04\x05\x02\x04\x05\x12\x04\x90\x01\x04\n\n\r\n\
    \x05\x04\x05\x02\x04\x01\x12\x04\x90\x01\x0b\x11\n\r\n\x05\x04\x05\x02\
    \x04\x03\x12\x04\x90\x01\x14\x15\n\x0c\n\x02\x04\x06\x12\x06\x93\x01\0\
    \x96\x01\x01\n\x0b\n\x03\x04\x06\x01\x12\x04\x93\x01\x08\"\n0\n\x04\x04\
    \x06\x02\0\x12\x04\x95\x01\x04%\x1a\"\x20Network-server\x20object\x20to\
    \x20update.\n\n\x0f\n\x05\x04\x06\x02\0\x04\x12\x06\x95\x01\x04\x93\x01$\
    \n\r\n\x05\x04\x06\x02\0\x06\x12\x04\x95\x01\x04\x11\n\r\n\x05\x04\x06\
    \x02\0\x01\x12\x04\x95\x01\x12\x20\n\r\n\x05\x04\x06\x02\0\x03\x12\x04\
    \x95\x01#$\n\x0c\n\x02\x04\x07\x12\x06\x98\x01\0\x9b\x01\x01\n\x0b\n\x03\
    \x04\x07\x01\x12\x04\x98\x01\x08\"\n\"\n\x04\x04\x07\x02\0\x12\x04\x9a\
    \x01\x04\x11\x1a\x14\x20Network-server\x20ID.\n\n\x0f\n\x05\x04\x07\x02\
    \0\x04\x12\x06\x9a\x01\x04\x98\x01$\n\r\n\x05\x04\x07\x02\0\x05\x12\x04\
    \x9a\x01\x04\t\n\r\n\x05\x04\x07\x02\0\x01\x12\x04\x9a\x01\n\x0c\n\r\n\
    \x05\x04\x07\x02\0\x03\x12\x04\x9a\x01\x0f\x10\n\x0c\n\x02\x04\x08\x12\
    \x06\x9d\x01\0\xa6\x01\x01\n\x0b\n\x03\x04\x08\x01\x12\x04\x9d\x01\x08\
    \x20\n.\n\x04\x04\x08\x02\0\x12\x04\x9f\x01\x04\x14\x1a\x20\x20Max\x20nu\
    mber\x20of\x20items\x20to\x20return.\n\n\x0f\n\x05\x04\x08\x02\0\x04\x12\
    \x06\x9f\x01\x04\x9d\x01\"\n\r\n\x05\x04\x08\x02\0\x05\x12\x04\x9f\x01\
    \x04\t\n\r\n\x05\x04\x08\x02\0\x01\x12\x04\x9f\x01\n\x0f\n\r\n\x05\x04\
    \x08\x02\0\x03\x12\x04\x9f\x01\x12\x13\n:\n\x04\x04\x08\x02\x01\x12\x04\
    \xa2\x01\x04\x15\x1a,\x20Offset\x20in\x20the\x20result-set\x20(for\x20pa\
    gination).\n\n\x0f\n\x05\x04\x08\x02\x01\x04\x12\x06\xa2\x01\x04\x9f\x01\
    \x14\n\r\n\x05\x04\x08\x02\x01\x05\x12\x04\xa2\x01\x04\t\n\r\n\x05\x04\
    \x08\x02\x01\x01\x12\x04\xa2\x01\n\x10\n\r\n\x05\x04\x08\x02\x01\x03\x12\
    \x04\xa2\x01\x13\x14\n-\n\x04\x04\x08\x02\x02\x12\x04\xa5\x01\x04=\x1a\
    \x1f\x20Organization\x20id\x20to\x20filter\x20on.\n\n\x0f\n\x05\x04\x08\
    \x02\x02\x04\x12\x06\xa5\x01\x04\xa2\x01\x15\n\r\n\x05\x04\x08\x02\x02\
    \x05\x12\x04\xa5\x01\x04\t\n\r\n\x05\x04\x08\x02\x02\x01\x12\x04\xa5\x01\
    \n\x19\n\r\n\x05\x04\x08\x02\x02\x03\x12\x04\xa5\x01\x1c\x1d\n\r\n\x05\
    \x04\x08\x02\x02\x08\x12\x04\xa5\x01\x1e<\n\r\n\x05\x04\x08\x02\x02\n\
    \x12\x04\xa5\x01+;\n\x0c\n\x02\x04\t\x12\x06\xa8\x01\0\xae\x01\x01\n\x0b\
    \n\x03\x04\t\x01\x12\x04\xa8\x01\x08!\n0\n\x04\x04\t\x02\0\x12\x04\xaa\
    \x01\x04\x1a\x1a\"\x20Total\x20number\x20of\x20network-servers.\n\n\x0f\
    \n\x05\x04\t\x02\0\x04\x12\x06\xaa\x01\x04\xa8\x01#\n\r\n\x05\x04\t\x02\
    \0\x05\x12\x04\xaa\x01\x04\t\n\r\n\x05\x04\t\x02\0\x01\x12\x04\xaa\x01\n\
    \x15\n\r\n\x05\x04\t\x02\0\x03\x12\x04\xaa\x01\x18\x19\n6\n\x04\x04\t\
    \x02\x01\x12\x04\xad\x01\x04.\x1a(\x20Network-servers\x20within\x20the\
    \x20result-set.\n\n\r\n\x05\x04\t\x02\x01\x04\x12\x04\xad\x01\x04\x0c\n\
    \r\n\x05\x04\t\x02\x01\x06\x12\x04\xad\x01\r\"\n\r\n\x05\x04\t\x02\x01\
    \x01\x12\x04\xad\x01#)\n\r\n\x05\x04\t\x02\x01\x03\x12\x04\xad\x01,-b\
    \x06proto3\
";

static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy {
    lock: ::protobuf::lazy::ONCE_INIT,
    ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto,
};

fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
    ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap()
}

pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
    unsafe {
        file_descriptor_proto_lazy.get(|| {
            parse_descriptor_proto()
        })
    }
}