bayard-proto 0.8.2

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

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

#![allow(unused_attributes)]
#![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(unused_imports)]
#![allow(unused_results)]
//! Generated file from `indexpb.proto`

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

#[derive(PartialEq,Clone,Default)]
pub struct SearchReq {
    // message fields
    pub query: ::std::string::String,
    pub from: u64,
    pub limit: u64,
    pub exclude_count: bool,
    pub exclude_docs: bool,
    pub facet_field: ::std::string::String,
    pub facet_prefixes: ::protobuf::RepeatedField<::std::string::String>,
    pub client_id: u64,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string query = 1;


    pub fn get_query(&self) -> &str {
        &self.query
    }
    pub fn clear_query(&mut self) {
        self.query.clear();
    }

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

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

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

    // uint64 from = 2;


    pub fn get_from(&self) -> u64 {
        self.from
    }
    pub fn clear_from(&mut self) {
        self.from = 0;
    }

    // Param is passed by value, moved
    pub fn set_from(&mut self, v: u64) {
        self.from = v;
    }

    // uint64 limit = 3;


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

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

    // bool exclude_count = 4;


    pub fn get_exclude_count(&self) -> bool {
        self.exclude_count
    }
    pub fn clear_exclude_count(&mut self) {
        self.exclude_count = false;
    }

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

    // bool exclude_docs = 5;


    pub fn get_exclude_docs(&self) -> bool {
        self.exclude_docs
    }
    pub fn clear_exclude_docs(&mut self) {
        self.exclude_docs = false;
    }

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

    // string facet_field = 6;


    pub fn get_facet_field(&self) -> &str {
        &self.facet_field
    }
    pub fn clear_facet_field(&mut self) {
        self.facet_field.clear();
    }

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

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

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

    // repeated string facet_prefixes = 7;


    pub fn get_facet_prefixes(&self) -> &[::std::string::String] {
        &self.facet_prefixes
    }
    pub fn clear_facet_prefixes(&mut self) {
        self.facet_prefixes.clear();
    }

    // Param is passed by value, moved
    pub fn set_facet_prefixes(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
        self.facet_prefixes = v;
    }

    // Mutable pointer to the field.
    pub fn mut_facet_prefixes(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
        &mut self.facet_prefixes
    }

    // Take field
    pub fn take_facet_prefixes(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
        ::std::mem::replace(&mut self.facet_prefixes, ::protobuf::RepeatedField::new())
    }

    // uint64 client_id = 8;


    pub fn get_client_id(&self) -> u64 {
        self.client_id
    }
    pub fn clear_client_id(&mut self) {
        self.client_id = 0;
    }

    // Param is passed by value, moved
    pub fn set_client_id(&mut self, v: u64) {
        self.client_id = v;
    }
}

impl ::protobuf::Message for SearchReq {
    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 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.query)?;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.from = 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_uint64()?;
                    self.limit = tmp;
                },
                4 => {
                    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.exclude_count = tmp;
                },
                5 => {
                    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.exclude_docs = tmp;
                },
                6 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.facet_field)?;
                },
                7 => {
                    ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.facet_prefixes)?;
                },
                8 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.client_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.query.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.query);
        }
        if self.from != 0 {
            my_size += ::protobuf::rt::value_size(2, self.from, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.limit != 0 {
            my_size += ::protobuf::rt::value_size(3, self.limit, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.exclude_count != false {
            my_size += 2;
        }
        if self.exclude_docs != false {
            my_size += 2;
        }
        if !self.facet_field.is_empty() {
            my_size += ::protobuf::rt::string_size(6, &self.facet_field);
        }
        for value in &self.facet_prefixes {
            my_size += ::protobuf::rt::string_size(7, &value);
        };
        if self.client_id != 0 {
            my_size += ::protobuf::rt::value_size(8, self.client_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.query.is_empty() {
            os.write_string(1, &self.query)?;
        }
        if self.from != 0 {
            os.write_uint64(2, self.from)?;
        }
        if self.limit != 0 {
            os.write_uint64(3, self.limit)?;
        }
        if self.exclude_count != false {
            os.write_bool(4, self.exclude_count)?;
        }
        if self.exclude_docs != false {
            os.write_bool(5, self.exclude_docs)?;
        }
        if !self.facet_field.is_empty() {
            os.write_string(6, &self.facet_field)?;
        }
        for v in &self.facet_prefixes {
            os.write_string(7, &v)?;
        };
        if self.client_id != 0 {
            os.write_uint64(8, self.client_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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "query",
                |m: &SearchReq| { &m.query },
                |m: &mut SearchReq| { &mut m.query },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "from",
                |m: &SearchReq| { &m.from },
                |m: &mut SearchReq| { &mut m.from },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "limit",
                |m: &SearchReq| { &m.limit },
                |m: &mut SearchReq| { &mut m.limit },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "exclude_count",
                |m: &SearchReq| { &m.exclude_count },
                |m: &mut SearchReq| { &mut m.exclude_count },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "exclude_docs",
                |m: &SearchReq| { &m.exclude_docs },
                |m: &mut SearchReq| { &mut m.exclude_docs },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "facet_field",
                |m: &SearchReq| { &m.facet_field },
                |m: &mut SearchReq| { &mut m.facet_field },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "facet_prefixes",
                |m: &SearchReq| { &m.facet_prefixes },
                |m: &mut SearchReq| { &mut m.facet_prefixes },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "client_id",
                |m: &SearchReq| { &m.client_id },
                |m: &mut SearchReq| { &mut m.client_id },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<SearchReq>(
                "SearchReq",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static SearchReq {
        static instance: ::protobuf::rt::LazyV2<SearchReq> = ::protobuf::rt::LazyV2::INIT;
        instance.get(SearchReq::new)
    }
}

impl ::protobuf::Clear for SearchReq {
    fn clear(&mut self) {
        self.query.clear();
        self.from = 0;
        self.limit = 0;
        self.exclude_count = false;
        self.exclude_docs = false;
        self.facet_field.clear();
        self.facet_prefixes.clear();
        self.client_id = 0;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct SearchReply {
    // message fields
    pub state: super::commonpb::State,
    pub search_result: ::std::string::String,
    pub address_map: ::std::vec::Vec<u8>,
    pub leader_id: u64,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // .bayard.common.State state = 1;


    pub fn get_state(&self) -> super::commonpb::State {
        self.state
    }
    pub fn clear_state(&mut self) {
        self.state = super::commonpb::State::OK;
    }

    // Param is passed by value, moved
    pub fn set_state(&mut self, v: super::commonpb::State) {
        self.state = v;
    }

    // string search_result = 2;


    pub fn get_search_result(&self) -> &str {
        &self.search_result
    }
    pub fn clear_search_result(&mut self) {
        self.search_result.clear();
    }

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

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

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

    // bytes address_map = 3;


    pub fn get_address_map(&self) -> &[u8] {
        &self.address_map
    }
    pub fn clear_address_map(&mut self) {
        self.address_map.clear();
    }

    // Param is passed by value, moved
    pub fn set_address_map(&mut self, v: ::std::vec::Vec<u8>) {
        self.address_map = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_address_map(&mut self) -> &mut ::std::vec::Vec<u8> {
        &mut self.address_map
    }

    // Take field
    pub fn take_address_map(&mut self) -> ::std::vec::Vec<u8> {
        ::std::mem::replace(&mut self.address_map, ::std::vec::Vec::new())
    }

    // uint64 leader_id = 4;


    pub fn get_leader_id(&self) -> u64 {
        self.leader_id
    }
    pub fn clear_leader_id(&mut self) {
        self.leader_id = 0;
    }

    // Param is passed by value, moved
    pub fn set_leader_id(&mut self, v: u64) {
        self.leader_id = v;
    }
}

impl ::protobuf::Message for SearchReply {
    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 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.state, 1, &mut self.unknown_fields)?
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.search_result)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.address_map)?;
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.leader_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.state != super::commonpb::State::OK {
            my_size += ::protobuf::rt::enum_size(1, self.state);
        }
        if !self.search_result.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.search_result);
        }
        if !self.address_map.is_empty() {
            my_size += ::protobuf::rt::bytes_size(3, &self.address_map);
        }
        if self.leader_id != 0 {
            my_size += ::protobuf::rt::value_size(4, self.leader_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.state != super::commonpb::State::OK {
            os.write_enum(1, ::protobuf::ProtobufEnum::value(&self.state))?;
        }
        if !self.search_result.is_empty() {
            os.write_string(2, &self.search_result)?;
        }
        if !self.address_map.is_empty() {
            os.write_bytes(3, &self.address_map)?;
        }
        if self.leader_id != 0 {
            os.write_uint64(4, self.leader_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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<super::commonpb::State>>(
                "state",
                |m: &SearchReply| { &m.state },
                |m: &mut SearchReply| { &mut m.state },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "search_result",
                |m: &SearchReply| { &m.search_result },
                |m: &mut SearchReply| { &mut m.search_result },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "address_map",
                |m: &SearchReply| { &m.address_map },
                |m: &mut SearchReply| { &mut m.address_map },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "leader_id",
                |m: &SearchReply| { &m.leader_id },
                |m: &mut SearchReply| { &mut m.leader_id },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<SearchReply>(
                "SearchReply",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static SearchReply {
        static instance: ::protobuf::rt::LazyV2<SearchReply> = ::protobuf::rt::LazyV2::INIT;
        instance.get(SearchReply::new)
    }
}

impl ::protobuf::Clear for SearchReply {
    fn clear(&mut self) {
        self.state = super::commonpb::State::OK;
        self.search_result.clear();
        self.address_map.clear();
        self.leader_id = 0;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct GetReq {
    // message fields
    pub id: ::std::string::String,
    pub client_id: u64,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string id = 1;


    pub fn get_id(&self) -> &str {
        &self.id
    }
    pub fn clear_id(&mut self) {
        self.id.clear();
    }

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

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

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

    // uint64 client_id = 2;


    pub fn get_client_id(&self) -> u64 {
        self.client_id
    }
    pub fn clear_client_id(&mut self) {
        self.client_id = 0;
    }

    // Param is passed by value, moved
    pub fn set_client_id(&mut self, v: u64) {
        self.client_id = v;
    }
}

impl ::protobuf::Message for GetReq {
    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 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.id)?;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.client_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.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.id);
        }
        if self.client_id != 0 {
            my_size += ::protobuf::rt::value_size(2, self.client_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.is_empty() {
            os.write_string(1, &self.id)?;
        }
        if self.client_id != 0 {
            os.write_uint64(2, self.client_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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "id",
                |m: &GetReq| { &m.id },
                |m: &mut GetReq| { &mut m.id },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "client_id",
                |m: &GetReq| { &m.client_id },
                |m: &mut GetReq| { &mut m.client_id },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<GetReq>(
                "GetReq",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static GetReq {
        static instance: ::protobuf::rt::LazyV2<GetReq> = ::protobuf::rt::LazyV2::INIT;
        instance.get(GetReq::new)
    }
}

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct GetReply {
    // message fields
    pub state: super::commonpb::State,
    pub doc: ::std::string::String,
    pub address_map: ::std::vec::Vec<u8>,
    pub leader_id: u64,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // .bayard.common.State state = 1;


    pub fn get_state(&self) -> super::commonpb::State {
        self.state
    }
    pub fn clear_state(&mut self) {
        self.state = super::commonpb::State::OK;
    }

    // Param is passed by value, moved
    pub fn set_state(&mut self, v: super::commonpb::State) {
        self.state = v;
    }

    // string doc = 2;


    pub fn get_doc(&self) -> &str {
        &self.doc
    }
    pub fn clear_doc(&mut self) {
        self.doc.clear();
    }

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

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

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

    // bytes address_map = 3;


    pub fn get_address_map(&self) -> &[u8] {
        &self.address_map
    }
    pub fn clear_address_map(&mut self) {
        self.address_map.clear();
    }

    // Param is passed by value, moved
    pub fn set_address_map(&mut self, v: ::std::vec::Vec<u8>) {
        self.address_map = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_address_map(&mut self) -> &mut ::std::vec::Vec<u8> {
        &mut self.address_map
    }

    // Take field
    pub fn take_address_map(&mut self) -> ::std::vec::Vec<u8> {
        ::std::mem::replace(&mut self.address_map, ::std::vec::Vec::new())
    }

    // uint64 leader_id = 4;


    pub fn get_leader_id(&self) -> u64 {
        self.leader_id
    }
    pub fn clear_leader_id(&mut self) {
        self.leader_id = 0;
    }

    // Param is passed by value, moved
    pub fn set_leader_id(&mut self, v: u64) {
        self.leader_id = v;
    }
}

impl ::protobuf::Message for GetReply {
    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 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.state, 1, &mut self.unknown_fields)?
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.doc)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.address_map)?;
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.leader_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.state != super::commonpb::State::OK {
            my_size += ::protobuf::rt::enum_size(1, self.state);
        }
        if !self.doc.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.doc);
        }
        if !self.address_map.is_empty() {
            my_size += ::protobuf::rt::bytes_size(3, &self.address_map);
        }
        if self.leader_id != 0 {
            my_size += ::protobuf::rt::value_size(4, self.leader_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.state != super::commonpb::State::OK {
            os.write_enum(1, ::protobuf::ProtobufEnum::value(&self.state))?;
        }
        if !self.doc.is_empty() {
            os.write_string(2, &self.doc)?;
        }
        if !self.address_map.is_empty() {
            os.write_bytes(3, &self.address_map)?;
        }
        if self.leader_id != 0 {
            os.write_uint64(4, self.leader_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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<super::commonpb::State>>(
                "state",
                |m: &GetReply| { &m.state },
                |m: &mut GetReply| { &mut m.state },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "doc",
                |m: &GetReply| { &m.doc },
                |m: &mut GetReply| { &mut m.doc },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "address_map",
                |m: &GetReply| { &m.address_map },
                |m: &mut GetReply| { &mut m.address_map },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "leader_id",
                |m: &GetReply| { &m.leader_id },
                |m: &mut GetReply| { &mut m.leader_id },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<GetReply>(
                "GetReply",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static GetReply {
        static instance: ::protobuf::rt::LazyV2<GetReply> = ::protobuf::rt::LazyV2::INIT;
        instance.get(GetReply::new)
    }
}

impl ::protobuf::Clear for GetReply {
    fn clear(&mut self) {
        self.state = super::commonpb::State::OK;
        self.doc.clear();
        self.address_map.clear();
        self.leader_id = 0;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct SetReq {
    // message fields
    pub doc: ::std::string::String,
    pub client_id: u64,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string doc = 1;


    pub fn get_doc(&self) -> &str {
        &self.doc
    }
    pub fn clear_doc(&mut self) {
        self.doc.clear();
    }

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

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

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

    // uint64 client_id = 2;


    pub fn get_client_id(&self) -> u64 {
        self.client_id
    }
    pub fn clear_client_id(&mut self) {
        self.client_id = 0;
    }

    // Param is passed by value, moved
    pub fn set_client_id(&mut self, v: u64) {
        self.client_id = v;
    }
}

impl ::protobuf::Message for SetReq {
    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 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.doc)?;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.client_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.doc.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.doc);
        }
        if self.client_id != 0 {
            my_size += ::protobuf::rt::value_size(2, self.client_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.doc.is_empty() {
            os.write_string(1, &self.doc)?;
        }
        if self.client_id != 0 {
            os.write_uint64(2, self.client_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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "doc",
                |m: &SetReq| { &m.doc },
                |m: &mut SetReq| { &mut m.doc },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "client_id",
                |m: &SetReq| { &m.client_id },
                |m: &mut SetReq| { &mut m.client_id },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<SetReq>(
                "SetReq",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static SetReq {
        static instance: ::protobuf::rt::LazyV2<SetReq> = ::protobuf::rt::LazyV2::INIT;
        instance.get(SetReq::new)
    }
}

impl ::protobuf::Clear for SetReq {
    fn clear(&mut self) {
        self.doc.clear();
        self.client_id = 0;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct SetReply {
    // message fields
    pub state: super::commonpb::State,
    pub address_map: ::std::vec::Vec<u8>,
    pub leader_id: u64,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // .bayard.common.State state = 1;


    pub fn get_state(&self) -> super::commonpb::State {
        self.state
    }
    pub fn clear_state(&mut self) {
        self.state = super::commonpb::State::OK;
    }

    // Param is passed by value, moved
    pub fn set_state(&mut self, v: super::commonpb::State) {
        self.state = v;
    }

    // bytes address_map = 2;


    pub fn get_address_map(&self) -> &[u8] {
        &self.address_map
    }
    pub fn clear_address_map(&mut self) {
        self.address_map.clear();
    }

    // Param is passed by value, moved
    pub fn set_address_map(&mut self, v: ::std::vec::Vec<u8>) {
        self.address_map = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_address_map(&mut self) -> &mut ::std::vec::Vec<u8> {
        &mut self.address_map
    }

    // Take field
    pub fn take_address_map(&mut self) -> ::std::vec::Vec<u8> {
        ::std::mem::replace(&mut self.address_map, ::std::vec::Vec::new())
    }

    // uint64 leader_id = 3;


    pub fn get_leader_id(&self) -> u64 {
        self.leader_id
    }
    pub fn clear_leader_id(&mut self) {
        self.leader_id = 0;
    }

    // Param is passed by value, moved
    pub fn set_leader_id(&mut self, v: u64) {
        self.leader_id = v;
    }
}

impl ::protobuf::Message for SetReply {
    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 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.state, 1, &mut self.unknown_fields)?
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.address_map)?;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.leader_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.state != super::commonpb::State::OK {
            my_size += ::protobuf::rt::enum_size(1, self.state);
        }
        if !self.address_map.is_empty() {
            my_size += ::protobuf::rt::bytes_size(2, &self.address_map);
        }
        if self.leader_id != 0 {
            my_size += ::protobuf::rt::value_size(3, self.leader_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.state != super::commonpb::State::OK {
            os.write_enum(1, ::protobuf::ProtobufEnum::value(&self.state))?;
        }
        if !self.address_map.is_empty() {
            os.write_bytes(2, &self.address_map)?;
        }
        if self.leader_id != 0 {
            os.write_uint64(3, self.leader_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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<super::commonpb::State>>(
                "state",
                |m: &SetReply| { &m.state },
                |m: &mut SetReply| { &mut m.state },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "address_map",
                |m: &SetReply| { &m.address_map },
                |m: &mut SetReply| { &mut m.address_map },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "leader_id",
                |m: &SetReply| { &m.leader_id },
                |m: &mut SetReply| { &mut m.leader_id },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<SetReply>(
                "SetReply",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static SetReply {
        static instance: ::protobuf::rt::LazyV2<SetReply> = ::protobuf::rt::LazyV2::INIT;
        instance.get(SetReply::new)
    }
}

impl ::protobuf::Clear for SetReply {
    fn clear(&mut self) {
        self.state = super::commonpb::State::OK;
        self.address_map.clear();
        self.leader_id = 0;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct DeleteReq {
    // message fields
    pub id: ::std::string::String,
    pub client_id: u64,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string id = 1;


    pub fn get_id(&self) -> &str {
        &self.id
    }
    pub fn clear_id(&mut self) {
        self.id.clear();
    }

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

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

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

    // uint64 client_id = 2;


    pub fn get_client_id(&self) -> u64 {
        self.client_id
    }
    pub fn clear_client_id(&mut self) {
        self.client_id = 0;
    }

    // Param is passed by value, moved
    pub fn set_client_id(&mut self, v: u64) {
        self.client_id = v;
    }
}

impl ::protobuf::Message for DeleteReq {
    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 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.id)?;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.client_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.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.id);
        }
        if self.client_id != 0 {
            my_size += ::protobuf::rt::value_size(2, self.client_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.is_empty() {
            os.write_string(1, &self.id)?;
        }
        if self.client_id != 0 {
            os.write_uint64(2, self.client_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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "id",
                |m: &DeleteReq| { &m.id },
                |m: &mut DeleteReq| { &mut m.id },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "client_id",
                |m: &DeleteReq| { &m.client_id },
                |m: &mut DeleteReq| { &mut m.client_id },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<DeleteReq>(
                "DeleteReq",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static DeleteReq {
        static instance: ::protobuf::rt::LazyV2<DeleteReq> = ::protobuf::rt::LazyV2::INIT;
        instance.get(DeleteReq::new)
    }
}

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct DeleteReply {
    // message fields
    pub state: super::commonpb::State,
    pub address_map: ::std::vec::Vec<u8>,
    pub leader_id: u64,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // .bayard.common.State state = 1;


    pub fn get_state(&self) -> super::commonpb::State {
        self.state
    }
    pub fn clear_state(&mut self) {
        self.state = super::commonpb::State::OK;
    }

    // Param is passed by value, moved
    pub fn set_state(&mut self, v: super::commonpb::State) {
        self.state = v;
    }

    // bytes address_map = 2;


    pub fn get_address_map(&self) -> &[u8] {
        &self.address_map
    }
    pub fn clear_address_map(&mut self) {
        self.address_map.clear();
    }

    // Param is passed by value, moved
    pub fn set_address_map(&mut self, v: ::std::vec::Vec<u8>) {
        self.address_map = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_address_map(&mut self) -> &mut ::std::vec::Vec<u8> {
        &mut self.address_map
    }

    // Take field
    pub fn take_address_map(&mut self) -> ::std::vec::Vec<u8> {
        ::std::mem::replace(&mut self.address_map, ::std::vec::Vec::new())
    }

    // uint64 leader_id = 3;


    pub fn get_leader_id(&self) -> u64 {
        self.leader_id
    }
    pub fn clear_leader_id(&mut self) {
        self.leader_id = 0;
    }

    // Param is passed by value, moved
    pub fn set_leader_id(&mut self, v: u64) {
        self.leader_id = v;
    }
}

impl ::protobuf::Message for DeleteReply {
    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 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.state, 1, &mut self.unknown_fields)?
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.address_map)?;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.leader_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.state != super::commonpb::State::OK {
            my_size += ::protobuf::rt::enum_size(1, self.state);
        }
        if !self.address_map.is_empty() {
            my_size += ::protobuf::rt::bytes_size(2, &self.address_map);
        }
        if self.leader_id != 0 {
            my_size += ::protobuf::rt::value_size(3, self.leader_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.state != super::commonpb::State::OK {
            os.write_enum(1, ::protobuf::ProtobufEnum::value(&self.state))?;
        }
        if !self.address_map.is_empty() {
            os.write_bytes(2, &self.address_map)?;
        }
        if self.leader_id != 0 {
            os.write_uint64(3, self.leader_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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<super::commonpb::State>>(
                "state",
                |m: &DeleteReply| { &m.state },
                |m: &mut DeleteReply| { &mut m.state },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "address_map",
                |m: &DeleteReply| { &m.address_map },
                |m: &mut DeleteReply| { &mut m.address_map },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "leader_id",
                |m: &DeleteReply| { &m.leader_id },
                |m: &mut DeleteReply| { &mut m.leader_id },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<DeleteReply>(
                "DeleteReply",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static DeleteReply {
        static instance: ::protobuf::rt::LazyV2<DeleteReply> = ::protobuf::rt::LazyV2::INIT;
        instance.get(DeleteReply::new)
    }
}

impl ::protobuf::Clear for DeleteReply {
    fn clear(&mut self) {
        self.state = super::commonpb::State::OK;
        self.address_map.clear();
        self.leader_id = 0;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct BulkSetReq {
    // message fields
    pub docs: ::std::string::String,
    pub client_id: u64,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string docs = 1;


    pub fn get_docs(&self) -> &str {
        &self.docs
    }
    pub fn clear_docs(&mut self) {
        self.docs.clear();
    }

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

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

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

    // uint64 client_id = 2;


    pub fn get_client_id(&self) -> u64 {
        self.client_id
    }
    pub fn clear_client_id(&mut self) {
        self.client_id = 0;
    }

    // Param is passed by value, moved
    pub fn set_client_id(&mut self, v: u64) {
        self.client_id = v;
    }
}

impl ::protobuf::Message for BulkSetReq {
    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 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.docs)?;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.client_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.docs.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.docs);
        }
        if self.client_id != 0 {
            my_size += ::protobuf::rt::value_size(2, self.client_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.docs.is_empty() {
            os.write_string(1, &self.docs)?;
        }
        if self.client_id != 0 {
            os.write_uint64(2, self.client_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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "docs",
                |m: &BulkSetReq| { &m.docs },
                |m: &mut BulkSetReq| { &mut m.docs },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "client_id",
                |m: &BulkSetReq| { &m.client_id },
                |m: &mut BulkSetReq| { &mut m.client_id },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<BulkSetReq>(
                "BulkSetReq",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static BulkSetReq {
        static instance: ::protobuf::rt::LazyV2<BulkSetReq> = ::protobuf::rt::LazyV2::INIT;
        instance.get(BulkSetReq::new)
    }
}

impl ::protobuf::Clear for BulkSetReq {
    fn clear(&mut self) {
        self.docs.clear();
        self.client_id = 0;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct BulkSetReply {
    // message fields
    pub state: super::commonpb::State,
    pub address_map: ::std::vec::Vec<u8>,
    pub leader_id: u64,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // .bayard.common.State state = 1;


    pub fn get_state(&self) -> super::commonpb::State {
        self.state
    }
    pub fn clear_state(&mut self) {
        self.state = super::commonpb::State::OK;
    }

    // Param is passed by value, moved
    pub fn set_state(&mut self, v: super::commonpb::State) {
        self.state = v;
    }

    // bytes address_map = 2;


    pub fn get_address_map(&self) -> &[u8] {
        &self.address_map
    }
    pub fn clear_address_map(&mut self) {
        self.address_map.clear();
    }

    // Param is passed by value, moved
    pub fn set_address_map(&mut self, v: ::std::vec::Vec<u8>) {
        self.address_map = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_address_map(&mut self) -> &mut ::std::vec::Vec<u8> {
        &mut self.address_map
    }

    // Take field
    pub fn take_address_map(&mut self) -> ::std::vec::Vec<u8> {
        ::std::mem::replace(&mut self.address_map, ::std::vec::Vec::new())
    }

    // uint64 leader_id = 3;


    pub fn get_leader_id(&self) -> u64 {
        self.leader_id
    }
    pub fn clear_leader_id(&mut self) {
        self.leader_id = 0;
    }

    // Param is passed by value, moved
    pub fn set_leader_id(&mut self, v: u64) {
        self.leader_id = v;
    }
}

impl ::protobuf::Message for BulkSetReply {
    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 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.state, 1, &mut self.unknown_fields)?
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.address_map)?;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.leader_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.state != super::commonpb::State::OK {
            my_size += ::protobuf::rt::enum_size(1, self.state);
        }
        if !self.address_map.is_empty() {
            my_size += ::protobuf::rt::bytes_size(2, &self.address_map);
        }
        if self.leader_id != 0 {
            my_size += ::protobuf::rt::value_size(3, self.leader_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.state != super::commonpb::State::OK {
            os.write_enum(1, ::protobuf::ProtobufEnum::value(&self.state))?;
        }
        if !self.address_map.is_empty() {
            os.write_bytes(2, &self.address_map)?;
        }
        if self.leader_id != 0 {
            os.write_uint64(3, self.leader_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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<super::commonpb::State>>(
                "state",
                |m: &BulkSetReply| { &m.state },
                |m: &mut BulkSetReply| { &mut m.state },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "address_map",
                |m: &BulkSetReply| { &m.address_map },
                |m: &mut BulkSetReply| { &mut m.address_map },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "leader_id",
                |m: &BulkSetReply| { &m.leader_id },
                |m: &mut BulkSetReply| { &mut m.leader_id },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<BulkSetReply>(
                "BulkSetReply",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static BulkSetReply {
        static instance: ::protobuf::rt::LazyV2<BulkSetReply> = ::protobuf::rt::LazyV2::INIT;
        instance.get(BulkSetReply::new)
    }
}

impl ::protobuf::Clear for BulkSetReply {
    fn clear(&mut self) {
        self.state = super::commonpb::State::OK;
        self.address_map.clear();
        self.leader_id = 0;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct BulkDeleteReq {
    // message fields
    pub docs: ::std::string::String,
    pub client_id: u64,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string docs = 1;


    pub fn get_docs(&self) -> &str {
        &self.docs
    }
    pub fn clear_docs(&mut self) {
        self.docs.clear();
    }

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

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

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

    // uint64 client_id = 2;


    pub fn get_client_id(&self) -> u64 {
        self.client_id
    }
    pub fn clear_client_id(&mut self) {
        self.client_id = 0;
    }

    // Param is passed by value, moved
    pub fn set_client_id(&mut self, v: u64) {
        self.client_id = v;
    }
}

impl ::protobuf::Message for BulkDeleteReq {
    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 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.docs)?;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.client_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.docs.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.docs);
        }
        if self.client_id != 0 {
            my_size += ::protobuf::rt::value_size(2, self.client_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.docs.is_empty() {
            os.write_string(1, &self.docs)?;
        }
        if self.client_id != 0 {
            os.write_uint64(2, self.client_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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "docs",
                |m: &BulkDeleteReq| { &m.docs },
                |m: &mut BulkDeleteReq| { &mut m.docs },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "client_id",
                |m: &BulkDeleteReq| { &m.client_id },
                |m: &mut BulkDeleteReq| { &mut m.client_id },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<BulkDeleteReq>(
                "BulkDeleteReq",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static BulkDeleteReq {
        static instance: ::protobuf::rt::LazyV2<BulkDeleteReq> = ::protobuf::rt::LazyV2::INIT;
        instance.get(BulkDeleteReq::new)
    }
}

impl ::protobuf::Clear for BulkDeleteReq {
    fn clear(&mut self) {
        self.docs.clear();
        self.client_id = 0;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct BulkDeleteReply {
    // message fields
    pub state: super::commonpb::State,
    pub address_map: ::std::vec::Vec<u8>,
    pub leader_id: u64,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // .bayard.common.State state = 1;


    pub fn get_state(&self) -> super::commonpb::State {
        self.state
    }
    pub fn clear_state(&mut self) {
        self.state = super::commonpb::State::OK;
    }

    // Param is passed by value, moved
    pub fn set_state(&mut self, v: super::commonpb::State) {
        self.state = v;
    }

    // bytes address_map = 2;


    pub fn get_address_map(&self) -> &[u8] {
        &self.address_map
    }
    pub fn clear_address_map(&mut self) {
        self.address_map.clear();
    }

    // Param is passed by value, moved
    pub fn set_address_map(&mut self, v: ::std::vec::Vec<u8>) {
        self.address_map = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_address_map(&mut self) -> &mut ::std::vec::Vec<u8> {
        &mut self.address_map
    }

    // Take field
    pub fn take_address_map(&mut self) -> ::std::vec::Vec<u8> {
        ::std::mem::replace(&mut self.address_map, ::std::vec::Vec::new())
    }

    // uint64 leader_id = 3;


    pub fn get_leader_id(&self) -> u64 {
        self.leader_id
    }
    pub fn clear_leader_id(&mut self) {
        self.leader_id = 0;
    }

    // Param is passed by value, moved
    pub fn set_leader_id(&mut self, v: u64) {
        self.leader_id = v;
    }
}

impl ::protobuf::Message for BulkDeleteReply {
    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 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.state, 1, &mut self.unknown_fields)?
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.address_map)?;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.leader_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.state != super::commonpb::State::OK {
            my_size += ::protobuf::rt::enum_size(1, self.state);
        }
        if !self.address_map.is_empty() {
            my_size += ::protobuf::rt::bytes_size(2, &self.address_map);
        }
        if self.leader_id != 0 {
            my_size += ::protobuf::rt::value_size(3, self.leader_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.state != super::commonpb::State::OK {
            os.write_enum(1, ::protobuf::ProtobufEnum::value(&self.state))?;
        }
        if !self.address_map.is_empty() {
            os.write_bytes(2, &self.address_map)?;
        }
        if self.leader_id != 0 {
            os.write_uint64(3, self.leader_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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<super::commonpb::State>>(
                "state",
                |m: &BulkDeleteReply| { &m.state },
                |m: &mut BulkDeleteReply| { &mut m.state },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "address_map",
                |m: &BulkDeleteReply| { &m.address_map },
                |m: &mut BulkDeleteReply| { &mut m.address_map },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "leader_id",
                |m: &BulkDeleteReply| { &m.leader_id },
                |m: &mut BulkDeleteReply| { &mut m.leader_id },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<BulkDeleteReply>(
                "BulkDeleteReply",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static BulkDeleteReply {
        static instance: ::protobuf::rt::LazyV2<BulkDeleteReply> = ::protobuf::rt::LazyV2::INIT;
        instance.get(BulkDeleteReply::new)
    }
}

impl ::protobuf::Clear for BulkDeleteReply {
    fn clear(&mut self) {
        self.state = super::commonpb::State::OK;
        self.address_map.clear();
        self.leader_id = 0;
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

    // uint64 client_id = 1;


    pub fn get_client_id(&self) -> u64 {
        self.client_id
    }
    pub fn clear_client_id(&mut self) {
        self.client_id = 0;
    }

    // Param is passed by value, moved
    pub fn set_client_id(&mut self, v: u64) {
        self.client_id = v;
    }
}

impl ::protobuf::Message for CommitReq {
    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_uint64()?;
                    self.client_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.client_id != 0 {
            my_size += ::protobuf::rt::value_size(1, self.client_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.client_id != 0 {
            os.write_uint64(1, self.client_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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "client_id",
                |m: &CommitReq| { &m.client_id },
                |m: &mut CommitReq| { &mut m.client_id },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CommitReq>(
                "CommitReq",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CommitReq {
        static instance: ::protobuf::rt::LazyV2<CommitReq> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CommitReq::new)
    }
}

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CommitReply {
    // message fields
    pub state: super::commonpb::State,
    pub address_map: ::std::vec::Vec<u8>,
    pub leader_id: u64,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // .bayard.common.State state = 1;


    pub fn get_state(&self) -> super::commonpb::State {
        self.state
    }
    pub fn clear_state(&mut self) {
        self.state = super::commonpb::State::OK;
    }

    // Param is passed by value, moved
    pub fn set_state(&mut self, v: super::commonpb::State) {
        self.state = v;
    }

    // bytes address_map = 2;


    pub fn get_address_map(&self) -> &[u8] {
        &self.address_map
    }
    pub fn clear_address_map(&mut self) {
        self.address_map.clear();
    }

    // Param is passed by value, moved
    pub fn set_address_map(&mut self, v: ::std::vec::Vec<u8>) {
        self.address_map = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_address_map(&mut self) -> &mut ::std::vec::Vec<u8> {
        &mut self.address_map
    }

    // Take field
    pub fn take_address_map(&mut self) -> ::std::vec::Vec<u8> {
        ::std::mem::replace(&mut self.address_map, ::std::vec::Vec::new())
    }

    // uint64 leader_id = 3;


    pub fn get_leader_id(&self) -> u64 {
        self.leader_id
    }
    pub fn clear_leader_id(&mut self) {
        self.leader_id = 0;
    }

    // Param is passed by value, moved
    pub fn set_leader_id(&mut self, v: u64) {
        self.leader_id = v;
    }
}

impl ::protobuf::Message for CommitReply {
    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 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.state, 1, &mut self.unknown_fields)?
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.address_map)?;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.leader_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.state != super::commonpb::State::OK {
            my_size += ::protobuf::rt::enum_size(1, self.state);
        }
        if !self.address_map.is_empty() {
            my_size += ::protobuf::rt::bytes_size(2, &self.address_map);
        }
        if self.leader_id != 0 {
            my_size += ::protobuf::rt::value_size(3, self.leader_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.state != super::commonpb::State::OK {
            os.write_enum(1, ::protobuf::ProtobufEnum::value(&self.state))?;
        }
        if !self.address_map.is_empty() {
            os.write_bytes(2, &self.address_map)?;
        }
        if self.leader_id != 0 {
            os.write_uint64(3, self.leader_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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<super::commonpb::State>>(
                "state",
                |m: &CommitReply| { &m.state },
                |m: &mut CommitReply| { &mut m.state },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "address_map",
                |m: &CommitReply| { &m.address_map },
                |m: &mut CommitReply| { &mut m.address_map },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "leader_id",
                |m: &CommitReply| { &m.leader_id },
                |m: &mut CommitReply| { &mut m.leader_id },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CommitReply>(
                "CommitReply",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CommitReply {
        static instance: ::protobuf::rt::LazyV2<CommitReply> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CommitReply::new)
    }
}

impl ::protobuf::Clear for CommitReply {
    fn clear(&mut self) {
        self.state = super::commonpb::State::OK;
        self.address_map.clear();
        self.leader_id = 0;
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

    // uint64 client_id = 1;


    pub fn get_client_id(&self) -> u64 {
        self.client_id
    }
    pub fn clear_client_id(&mut self) {
        self.client_id = 0;
    }

    // Param is passed by value, moved
    pub fn set_client_id(&mut self, v: u64) {
        self.client_id = v;
    }
}

impl ::protobuf::Message for RollbackReq {
    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_uint64()?;
                    self.client_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.client_id != 0 {
            my_size += ::protobuf::rt::value_size(1, self.client_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.client_id != 0 {
            os.write_uint64(1, self.client_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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "client_id",
                |m: &RollbackReq| { &m.client_id },
                |m: &mut RollbackReq| { &mut m.client_id },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<RollbackReq>(
                "RollbackReq",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static RollbackReq {
        static instance: ::protobuf::rt::LazyV2<RollbackReq> = ::protobuf::rt::LazyV2::INIT;
        instance.get(RollbackReq::new)
    }
}

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct RollbackReply {
    // message fields
    pub state: super::commonpb::State,
    pub address_map: ::std::vec::Vec<u8>,
    pub leader_id: u64,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // .bayard.common.State state = 1;


    pub fn get_state(&self) -> super::commonpb::State {
        self.state
    }
    pub fn clear_state(&mut self) {
        self.state = super::commonpb::State::OK;
    }

    // Param is passed by value, moved
    pub fn set_state(&mut self, v: super::commonpb::State) {
        self.state = v;
    }

    // bytes address_map = 2;


    pub fn get_address_map(&self) -> &[u8] {
        &self.address_map
    }
    pub fn clear_address_map(&mut self) {
        self.address_map.clear();
    }

    // Param is passed by value, moved
    pub fn set_address_map(&mut self, v: ::std::vec::Vec<u8>) {
        self.address_map = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_address_map(&mut self) -> &mut ::std::vec::Vec<u8> {
        &mut self.address_map
    }

    // Take field
    pub fn take_address_map(&mut self) -> ::std::vec::Vec<u8> {
        ::std::mem::replace(&mut self.address_map, ::std::vec::Vec::new())
    }

    // uint64 leader_id = 3;


    pub fn get_leader_id(&self) -> u64 {
        self.leader_id
    }
    pub fn clear_leader_id(&mut self) {
        self.leader_id = 0;
    }

    // Param is passed by value, moved
    pub fn set_leader_id(&mut self, v: u64) {
        self.leader_id = v;
    }
}

impl ::protobuf::Message for RollbackReply {
    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 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.state, 1, &mut self.unknown_fields)?
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.address_map)?;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.leader_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.state != super::commonpb::State::OK {
            my_size += ::protobuf::rt::enum_size(1, self.state);
        }
        if !self.address_map.is_empty() {
            my_size += ::protobuf::rt::bytes_size(2, &self.address_map);
        }
        if self.leader_id != 0 {
            my_size += ::protobuf::rt::value_size(3, self.leader_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.state != super::commonpb::State::OK {
            os.write_enum(1, ::protobuf::ProtobufEnum::value(&self.state))?;
        }
        if !self.address_map.is_empty() {
            os.write_bytes(2, &self.address_map)?;
        }
        if self.leader_id != 0 {
            os.write_uint64(3, self.leader_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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<super::commonpb::State>>(
                "state",
                |m: &RollbackReply| { &m.state },
                |m: &mut RollbackReply| { &mut m.state },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "address_map",
                |m: &RollbackReply| { &m.address_map },
                |m: &mut RollbackReply| { &mut m.address_map },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "leader_id",
                |m: &RollbackReply| { &m.leader_id },
                |m: &mut RollbackReply| { &mut m.leader_id },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<RollbackReply>(
                "RollbackReply",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static RollbackReply {
        static instance: ::protobuf::rt::LazyV2<RollbackReply> = ::protobuf::rt::LazyV2::INIT;
        instance.get(RollbackReply::new)
    }
}

impl ::protobuf::Clear for RollbackReply {
    fn clear(&mut self) {
        self.state = super::commonpb::State::OK;
        self.address_map.clear();
        self.leader_id = 0;
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

    // uint64 client_id = 1;


    pub fn get_client_id(&self) -> u64 {
        self.client_id
    }
    pub fn clear_client_id(&mut self) {
        self.client_id = 0;
    }

    // Param is passed by value, moved
    pub fn set_client_id(&mut self, v: u64) {
        self.client_id = v;
    }
}

impl ::protobuf::Message for MergeReq {
    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_uint64()?;
                    self.client_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.client_id != 0 {
            my_size += ::protobuf::rt::value_size(1, self.client_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.client_id != 0 {
            os.write_uint64(1, self.client_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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "client_id",
                |m: &MergeReq| { &m.client_id },
                |m: &mut MergeReq| { &mut m.client_id },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<MergeReq>(
                "MergeReq",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static MergeReq {
        static instance: ::protobuf::rt::LazyV2<MergeReq> = ::protobuf::rt::LazyV2::INIT;
        instance.get(MergeReq::new)
    }
}

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct MergeReply {
    // message fields
    pub state: super::commonpb::State,
    pub address_map: ::std::vec::Vec<u8>,
    pub leader_id: u64,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // .bayard.common.State state = 1;


    pub fn get_state(&self) -> super::commonpb::State {
        self.state
    }
    pub fn clear_state(&mut self) {
        self.state = super::commonpb::State::OK;
    }

    // Param is passed by value, moved
    pub fn set_state(&mut self, v: super::commonpb::State) {
        self.state = v;
    }

    // bytes address_map = 2;


    pub fn get_address_map(&self) -> &[u8] {
        &self.address_map
    }
    pub fn clear_address_map(&mut self) {
        self.address_map.clear();
    }

    // Param is passed by value, moved
    pub fn set_address_map(&mut self, v: ::std::vec::Vec<u8>) {
        self.address_map = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_address_map(&mut self) -> &mut ::std::vec::Vec<u8> {
        &mut self.address_map
    }

    // Take field
    pub fn take_address_map(&mut self) -> ::std::vec::Vec<u8> {
        ::std::mem::replace(&mut self.address_map, ::std::vec::Vec::new())
    }

    // uint64 leader_id = 3;


    pub fn get_leader_id(&self) -> u64 {
        self.leader_id
    }
    pub fn clear_leader_id(&mut self) {
        self.leader_id = 0;
    }

    // Param is passed by value, moved
    pub fn set_leader_id(&mut self, v: u64) {
        self.leader_id = v;
    }
}

impl ::protobuf::Message for MergeReply {
    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 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.state, 1, &mut self.unknown_fields)?
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.address_map)?;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.leader_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.state != super::commonpb::State::OK {
            my_size += ::protobuf::rt::enum_size(1, self.state);
        }
        if !self.address_map.is_empty() {
            my_size += ::protobuf::rt::bytes_size(2, &self.address_map);
        }
        if self.leader_id != 0 {
            my_size += ::protobuf::rt::value_size(3, self.leader_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.state != super::commonpb::State::OK {
            os.write_enum(1, ::protobuf::ProtobufEnum::value(&self.state))?;
        }
        if !self.address_map.is_empty() {
            os.write_bytes(2, &self.address_map)?;
        }
        if self.leader_id != 0 {
            os.write_uint64(3, self.leader_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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<super::commonpb::State>>(
                "state",
                |m: &MergeReply| { &m.state },
                |m: &mut MergeReply| { &mut m.state },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "address_map",
                |m: &MergeReply| { &m.address_map },
                |m: &mut MergeReply| { &mut m.address_map },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "leader_id",
                |m: &MergeReply| { &m.leader_id },
                |m: &mut MergeReply| { &mut m.leader_id },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<MergeReply>(
                "MergeReply",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static MergeReply {
        static instance: ::protobuf::rt::LazyV2<MergeReply> = ::protobuf::rt::LazyV2::INIT;
        instance.get(MergeReply::new)
    }
}

impl ::protobuf::Clear for MergeReply {
    fn clear(&mut self) {
        self.state = super::commonpb::State::OK;
        self.address_map.clear();
        self.leader_id = 0;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct SchemaReq {
    // message fields
    pub client_id: u64,
    pub seq: u64,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // uint64 client_id = 1;


    pub fn get_client_id(&self) -> u64 {
        self.client_id
    }
    pub fn clear_client_id(&mut self) {
        self.client_id = 0;
    }

    // Param is passed by value, moved
    pub fn set_client_id(&mut self, v: u64) {
        self.client_id = v;
    }

    // uint64 seq = 2;


    pub fn get_seq(&self) -> u64 {
        self.seq
    }
    pub fn clear_seq(&mut self) {
        self.seq = 0;
    }

    // Param is passed by value, moved
    pub fn set_seq(&mut self, v: u64) {
        self.seq = v;
    }
}

impl ::protobuf::Message for SchemaReq {
    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_uint64()?;
                    self.client_id = 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_uint64()?;
                    self.seq = 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.client_id != 0 {
            my_size += ::protobuf::rt::value_size(1, self.client_id, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.seq != 0 {
            my_size += ::protobuf::rt::value_size(2, self.seq, ::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.client_id != 0 {
            os.write_uint64(1, self.client_id)?;
        }
        if self.seq != 0 {
            os.write_uint64(2, self.seq)?;
        }
        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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "client_id",
                |m: &SchemaReq| { &m.client_id },
                |m: &mut SchemaReq| { &mut m.client_id },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "seq",
                |m: &SchemaReq| { &m.seq },
                |m: &mut SchemaReq| { &mut m.seq },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<SchemaReq>(
                "SchemaReq",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static SchemaReq {
        static instance: ::protobuf::rt::LazyV2<SchemaReq> = ::protobuf::rt::LazyV2::INIT;
        instance.get(SchemaReq::new)
    }
}

impl ::protobuf::Clear for SchemaReq {
    fn clear(&mut self) {
        self.client_id = 0;
        self.seq = 0;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct SchemaReply {
    // message fields
    pub state: super::commonpb::State,
    pub schema: ::std::string::String,
    pub address_map: ::std::vec::Vec<u8>,
    pub leader_id: u64,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // .bayard.common.State state = 1;


    pub fn get_state(&self) -> super::commonpb::State {
        self.state
    }
    pub fn clear_state(&mut self) {
        self.state = super::commonpb::State::OK;
    }

    // Param is passed by value, moved
    pub fn set_state(&mut self, v: super::commonpb::State) {
        self.state = v;
    }

    // string schema = 2;


    pub fn get_schema(&self) -> &str {
        &self.schema
    }
    pub fn clear_schema(&mut self) {
        self.schema.clear();
    }

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

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

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

    // bytes address_map = 3;


    pub fn get_address_map(&self) -> &[u8] {
        &self.address_map
    }
    pub fn clear_address_map(&mut self) {
        self.address_map.clear();
    }

    // Param is passed by value, moved
    pub fn set_address_map(&mut self, v: ::std::vec::Vec<u8>) {
        self.address_map = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_address_map(&mut self) -> &mut ::std::vec::Vec<u8> {
        &mut self.address_map
    }

    // Take field
    pub fn take_address_map(&mut self) -> ::std::vec::Vec<u8> {
        ::std::mem::replace(&mut self.address_map, ::std::vec::Vec::new())
    }

    // uint64 leader_id = 4;


    pub fn get_leader_id(&self) -> u64 {
        self.leader_id
    }
    pub fn clear_leader_id(&mut self) {
        self.leader_id = 0;
    }

    // Param is passed by value, moved
    pub fn set_leader_id(&mut self, v: u64) {
        self.leader_id = v;
    }
}

impl ::protobuf::Message for SchemaReply {
    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 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.state, 1, &mut self.unknown_fields)?
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.schema)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.address_map)?;
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.leader_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.state != super::commonpb::State::OK {
            my_size += ::protobuf::rt::enum_size(1, self.state);
        }
        if !self.schema.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.schema);
        }
        if !self.address_map.is_empty() {
            my_size += ::protobuf::rt::bytes_size(3, &self.address_map);
        }
        if self.leader_id != 0 {
            my_size += ::protobuf::rt::value_size(4, self.leader_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.state != super::commonpb::State::OK {
            os.write_enum(1, ::protobuf::ProtobufEnum::value(&self.state))?;
        }
        if !self.schema.is_empty() {
            os.write_string(2, &self.schema)?;
        }
        if !self.address_map.is_empty() {
            os.write_bytes(3, &self.address_map)?;
        }
        if self.leader_id != 0 {
            os.write_uint64(4, self.leader_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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<super::commonpb::State>>(
                "state",
                |m: &SchemaReply| { &m.state },
                |m: &mut SchemaReply| { &mut m.state },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "schema",
                |m: &SchemaReply| { &m.schema },
                |m: &mut SchemaReply| { &mut m.schema },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "address_map",
                |m: &SchemaReply| { &m.address_map },
                |m: &mut SchemaReply| { &mut m.address_map },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "leader_id",
                |m: &SchemaReply| { &m.leader_id },
                |m: &mut SchemaReply| { &mut m.leader_id },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<SchemaReply>(
                "SchemaReply",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static SchemaReply {
        static instance: ::protobuf::rt::LazyV2<SchemaReply> = ::protobuf::rt::LazyV2::INIT;
        instance.get(SchemaReply::new)
    }
}

impl ::protobuf::Clear for SchemaReply {
    fn clear(&mut self) {
        self.state = super::commonpb::State::OK;
        self.schema.clear();
        self.address_map.clear();
        self.leader_id = 0;
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

    // uint64 client_id = 1;


    pub fn get_client_id(&self) -> u64 {
        self.client_id
    }
    pub fn clear_client_id(&mut self) {
        self.client_id = 0;
    }

    // Param is passed by value, moved
    pub fn set_client_id(&mut self, v: u64) {
        self.client_id = v;
    }
}

impl ::protobuf::Message for StatusReq {
    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_uint64()?;
                    self.client_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.client_id != 0 {
            my_size += ::protobuf::rt::value_size(1, self.client_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.client_id != 0 {
            os.write_uint64(1, self.client_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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "client_id",
                |m: &StatusReq| { &m.client_id },
                |m: &mut StatusReq| { &mut m.client_id },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<StatusReq>(
                "StatusReq",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static StatusReq {
        static instance: ::protobuf::rt::LazyV2<StatusReq> = ::protobuf::rt::LazyV2::INIT;
        instance.get(StatusReq::new)
    }
}

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct StatusReply {
    // message fields
    pub state: super::commonpb::State,
    pub status: ::std::string::String,
    pub address_map: ::std::vec::Vec<u8>,
    pub leader_id: u64,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // .bayard.common.State state = 1;


    pub fn get_state(&self) -> super::commonpb::State {
        self.state
    }
    pub fn clear_state(&mut self) {
        self.state = super::commonpb::State::OK;
    }

    // Param is passed by value, moved
    pub fn set_state(&mut self, v: super::commonpb::State) {
        self.state = v;
    }

    // string status = 2;


    pub fn get_status(&self) -> &str {
        &self.status
    }
    pub fn clear_status(&mut self) {
        self.status.clear();
    }

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

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

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

    // bytes address_map = 3;


    pub fn get_address_map(&self) -> &[u8] {
        &self.address_map
    }
    pub fn clear_address_map(&mut self) {
        self.address_map.clear();
    }

    // Param is passed by value, moved
    pub fn set_address_map(&mut self, v: ::std::vec::Vec<u8>) {
        self.address_map = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_address_map(&mut self) -> &mut ::std::vec::Vec<u8> {
        &mut self.address_map
    }

    // Take field
    pub fn take_address_map(&mut self) -> ::std::vec::Vec<u8> {
        ::std::mem::replace(&mut self.address_map, ::std::vec::Vec::new())
    }

    // uint64 leader_id = 4;


    pub fn get_leader_id(&self) -> u64 {
        self.leader_id
    }
    pub fn clear_leader_id(&mut self) {
        self.leader_id = 0;
    }

    // Param is passed by value, moved
    pub fn set_leader_id(&mut self, v: u64) {
        self.leader_id = v;
    }
}

impl ::protobuf::Message for StatusReply {
    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 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.state, 1, &mut self.unknown_fields)?
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.status)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.address_map)?;
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.leader_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.state != super::commonpb::State::OK {
            my_size += ::protobuf::rt::enum_size(1, self.state);
        }
        if !self.status.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.status);
        }
        if !self.address_map.is_empty() {
            my_size += ::protobuf::rt::bytes_size(3, &self.address_map);
        }
        if self.leader_id != 0 {
            my_size += ::protobuf::rt::value_size(4, self.leader_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.state != super::commonpb::State::OK {
            os.write_enum(1, ::protobuf::ProtobufEnum::value(&self.state))?;
        }
        if !self.status.is_empty() {
            os.write_string(2, &self.status)?;
        }
        if !self.address_map.is_empty() {
            os.write_bytes(3, &self.address_map)?;
        }
        if self.leader_id != 0 {
            os.write_uint64(4, self.leader_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: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<super::commonpb::State>>(
                "state",
                |m: &StatusReply| { &m.state },
                |m: &mut StatusReply| { &mut m.state },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "status",
                |m: &StatusReply| { &m.status },
                |m: &mut StatusReply| { &mut m.status },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "address_map",
                |m: &StatusReply| { &m.address_map },
                |m: &mut StatusReply| { &mut m.address_map },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
                "leader_id",
                |m: &StatusReply| { &m.leader_id },
                |m: &mut StatusReply| { &mut m.leader_id },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<StatusReply>(
                "StatusReply",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static StatusReply {
        static instance: ::protobuf::rt::LazyV2<StatusReply> = ::protobuf::rt::LazyV2::INIT;
        instance.get(StatusReply::new)
    }
}

impl ::protobuf::Clear for StatusReply {
    fn clear(&mut self) {
        self.state = super::commonpb::State::OK;
        self.status.clear();
        self.address_map.clear();
        self.leader_id = 0;
        self.unknown_fields.clear();
    }
}

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

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

static file_descriptor_proto_data: &'static [u8] = b"\
    \n\rindexpb.proto\x12\x0cbayard.index\x1a\x0ecommonpb.proto\"\xf8\x01\n\
    \tSearchReq\x12\x14\n\x05query\x18\x01\x20\x01(\tR\x05query\x12\x12\n\
    \x04from\x18\x02\x20\x01(\x04R\x04from\x12\x14\n\x05limit\x18\x03\x20\
    \x01(\x04R\x05limit\x12#\n\rexclude_count\x18\x04\x20\x01(\x08R\x0cexclu\
    deCount\x12!\n\x0cexclude_docs\x18\x05\x20\x01(\x08R\x0bexcludeDocs\x12\
    \x1f\n\x0bfacet_field\x18\x06\x20\x01(\tR\nfacetField\x12%\n\x0efacet_pr\
    efixes\x18\x07\x20\x03(\tR\rfacetPrefixes\x12\x1b\n\tclient_id\x18\x08\
    \x20\x01(\x04R\x08clientId\"\x9c\x01\n\x0bSearchReply\x12*\n\x05state\
    \x18\x01\x20\x01(\x0e2\x14.bayard.common.StateR\x05state\x12#\n\rsearch_\
    result\x18\x02\x20\x01(\tR\x0csearchResult\x12\x1f\n\x0baddress_map\x18\
    \x03\x20\x01(\x0cR\naddressMap\x12\x1b\n\tleader_id\x18\x04\x20\x01(\x04\
    R\x08leaderId\"5\n\x06GetReq\x12\x0e\n\x02id\x18\x01\x20\x01(\tR\x02id\
    \x12\x1b\n\tclient_id\x18\x02\x20\x01(\x04R\x08clientId\"\x86\x01\n\x08G\
    etReply\x12*\n\x05state\x18\x01\x20\x01(\x0e2\x14.bayard.common.StateR\
    \x05state\x12\x10\n\x03doc\x18\x02\x20\x01(\tR\x03doc\x12\x1f\n\x0baddre\
    ss_map\x18\x03\x20\x01(\x0cR\naddressMap\x12\x1b\n\tleader_id\x18\x04\
    \x20\x01(\x04R\x08leaderId\"7\n\x06SetReq\x12\x10\n\x03doc\x18\x01\x20\
    \x01(\tR\x03doc\x12\x1b\n\tclient_id\x18\x02\x20\x01(\x04R\x08clientId\"\
    t\n\x08SetReply\x12*\n\x05state\x18\x01\x20\x01(\x0e2\x14.bayard.common.\
    StateR\x05state\x12\x1f\n\x0baddress_map\x18\x02\x20\x01(\x0cR\naddressM\
    ap\x12\x1b\n\tleader_id\x18\x03\x20\x01(\x04R\x08leaderId\"8\n\tDeleteRe\
    q\x12\x0e\n\x02id\x18\x01\x20\x01(\tR\x02id\x12\x1b\n\tclient_id\x18\x02\
    \x20\x01(\x04R\x08clientId\"w\n\x0bDeleteReply\x12*\n\x05state\x18\x01\
    \x20\x01(\x0e2\x14.bayard.common.StateR\x05state\x12\x1f\n\x0baddress_ma\
    p\x18\x02\x20\x01(\x0cR\naddressMap\x12\x1b\n\tleader_id\x18\x03\x20\x01\
    (\x04R\x08leaderId\"=\n\nBulkSetReq\x12\x12\n\x04docs\x18\x01\x20\x01(\t\
    R\x04docs\x12\x1b\n\tclient_id\x18\x02\x20\x01(\x04R\x08clientId\"x\n\
    \x0cBulkSetReply\x12*\n\x05state\x18\x01\x20\x01(\x0e2\x14.bayard.common\
    .StateR\x05state\x12\x1f\n\x0baddress_map\x18\x02\x20\x01(\x0cR\naddress\
    Map\x12\x1b\n\tleader_id\x18\x03\x20\x01(\x04R\x08leaderId\"@\n\rBulkDel\
    eteReq\x12\x12\n\x04docs\x18\x01\x20\x01(\tR\x04docs\x12\x1b\n\tclient_i\
    d\x18\x02\x20\x01(\x04R\x08clientId\"{\n\x0fBulkDeleteReply\x12*\n\x05st\
    ate\x18\x01\x20\x01(\x0e2\x14.bayard.common.StateR\x05state\x12\x1f\n\
    \x0baddress_map\x18\x02\x20\x01(\x0cR\naddressMap\x12\x1b\n\tleader_id\
    \x18\x03\x20\x01(\x04R\x08leaderId\"(\n\tCommitReq\x12\x1b\n\tclient_id\
    \x18\x01\x20\x01(\x04R\x08clientId\"w\n\x0bCommitReply\x12*\n\x05state\
    \x18\x01\x20\x01(\x0e2\x14.bayard.common.StateR\x05state\x12\x1f\n\x0bad\
    dress_map\x18\x02\x20\x01(\x0cR\naddressMap\x12\x1b\n\tleader_id\x18\x03\
    \x20\x01(\x04R\x08leaderId\"*\n\x0bRollbackReq\x12\x1b\n\tclient_id\x18\
    \x01\x20\x01(\x04R\x08clientId\"y\n\rRollbackReply\x12*\n\x05state\x18\
    \x01\x20\x01(\x0e2\x14.bayard.common.StateR\x05state\x12\x1f\n\x0baddres\
    s_map\x18\x02\x20\x01(\x0cR\naddressMap\x12\x1b\n\tleader_id\x18\x03\x20\
    \x01(\x04R\x08leaderId\"'\n\x08MergeReq\x12\x1b\n\tclient_id\x18\x01\x20\
    \x01(\x04R\x08clientId\"v\n\nMergeReply\x12*\n\x05state\x18\x01\x20\x01(\
    \x0e2\x14.bayard.common.StateR\x05state\x12\x1f\n\x0baddress_map\x18\x02\
    \x20\x01(\x0cR\naddressMap\x12\x1b\n\tleader_id\x18\x03\x20\x01(\x04R\
    \x08leaderId\":\n\tSchemaReq\x12\x1b\n\tclient_id\x18\x01\x20\x01(\x04R\
    \x08clientId\x12\x10\n\x03seq\x18\x02\x20\x01(\x04R\x03seq\"\x8f\x01\n\
    \x0bSchemaReply\x12*\n\x05state\x18\x01\x20\x01(\x0e2\x14.bayard.common.\
    StateR\x05state\x12\x16\n\x06schema\x18\x02\x20\x01(\tR\x06schema\x12\
    \x1f\n\x0baddress_map\x18\x03\x20\x01(\x0cR\naddressMap\x12\x1b\n\tleade\
    r_id\x18\x04\x20\x01(\x04R\x08leaderId\"(\n\tStatusReq\x12\x1b\n\tclient\
    _id\x18\x01\x20\x01(\x04R\x08clientId\"\x8f\x01\n\x0bStatusReply\x12*\n\
    \x05state\x18\x01\x20\x01(\x0e2\x14.bayard.common.StateR\x05state\x12\
    \x16\n\x06status\x18\x02\x20\x01(\tR\x06status\x12\x1f\n\x0baddress_map\
    \x18\x03\x20\x01(\x0cR\naddressMap\x12\x1b\n\tleader_id\x18\x04\x20\x01(\
    \x04R\x08leaderId2\xce\x05\n\x0cIndexService\x125\n\x03Get\x12\x14.bayar\
    d.index.GetReq\x1a\x16.bayard.index.GetReply\"\0\x12>\n\x06Search\x12\
    \x17.bayard.index.SearchReq\x1a\x19.bayard.index.SearchReply\"\0\x125\n\
    \x03Set\x12\x14.bayard.index.SetReq\x1a\x16.bayard.index.SetReply\"\0\
    \x12>\n\x06Delete\x12\x17.bayard.index.DeleteReq\x1a\x19.bayard.index.De\
    leteReply\"\0\x12A\n\x07BulkSet\x12\x18.bayard.index.BulkSetReq\x1a\x1a.\
    bayard.index.BulkSetReply\"\0\x12J\n\nBulkDelete\x12\x1b.bayard.index.Bu\
    lkDeleteReq\x1a\x1d.bayard.index.BulkDeleteReply\"\0\x12>\n\x06Commit\
    \x12\x17.bayard.index.CommitReq\x1a\x19.bayard.index.CommitReply\"\0\x12\
    D\n\x08Rollback\x12\x19.bayard.index.RollbackReq\x1a\x1b.bayard.index.Ro\
    llbackReply\"\0\x12;\n\x05Merge\x12\x16.bayard.index.MergeReq\x1a\x18.ba\
    yard.index.MergeReply\"\0\x12>\n\x06Schema\x12\x17.bayard.index.SchemaRe\
    q\x1a\x19.bayard.index.SchemaReply\"\0\x12>\n\x06Status\x12\x17.bayard.i\
    ndex.StatusReq\x1a\x19.bayard.index.StatusReply\"\0B\x0bZ\tpkg/protoJ\
    \xb4+\n\x07\x12\x05\0\0\x93\x01\x01\n\x08\n\x01\x0c\x12\x03\0\0\x12\n\t\
    \n\x02\x03\0\x12\x03\x02\x07\x17\n\x08\n\x01\x02\x12\x03\x04\x08\x14\n\
    \x08\n\x01\x08\x12\x03\x06\0\x20\n\t\n\x02\x08\x0b\x12\x03\x06\0\x20\n\n\
    \n\x02\x06\0\x12\x04\x08\0\x14\x01\n\n\n\x03\x06\0\x01\x12\x03\x08\x08\
    \x14\n\x0b\n\x04\x06\0\x02\0\x12\x03\t\x04)\n\x0c\n\x05\x06\0\x02\0\x01\
    \x12\x03\t\x08\x0b\n\x0c\n\x05\x06\0\x02\0\x02\x12\x03\t\x0c\x12\n\x0c\n\
    \x05\x06\0\x02\0\x03\x12\x03\t\x1d%\n\x0b\n\x04\x06\0\x02\x01\x12\x03\n\
    \x043\n\x0c\n\x05\x06\0\x02\x01\x01\x12\x03\n\x08\x0e\n\x0c\n\x05\x06\0\
    \x02\x01\x02\x12\x03\n\x10\x19\n\x0c\n\x05\x06\0\x02\x01\x03\x12\x03\n$/\
    \n\x0b\n\x04\x06\0\x02\x02\x12\x03\x0b\x04)\n\x0c\n\x05\x06\0\x02\x02\
    \x01\x12\x03\x0b\x08\x0b\n\x0c\n\x05\x06\0\x02\x02\x02\x12\x03\x0b\x0c\
    \x12\n\x0c\n\x05\x06\0\x02\x02\x03\x12\x03\x0b\x1d%\n\x0b\n\x04\x06\0\
    \x02\x03\x12\x03\x0c\x042\n\x0c\n\x05\x06\0\x02\x03\x01\x12\x03\x0c\x08\
    \x0e\n\x0c\n\x05\x06\0\x02\x03\x02\x12\x03\x0c\x0f\x18\n\x0c\n\x05\x06\0\
    \x02\x03\x03\x12\x03\x0c#.\n\x0b\n\x04\x06\0\x02\x04\x12\x03\r\x046\n\
    \x0c\n\x05\x06\0\x02\x04\x01\x12\x03\r\x08\x0f\n\x0c\n\x05\x06\0\x02\x04\
    \x02\x12\x03\r\x11\x1b\n\x0c\n\x05\x06\0\x02\x04\x03\x12\x03\r&2\n\x0b\n\
    \x04\x06\0\x02\x05\x12\x03\x0e\x04?\n\x0c\n\x05\x06\0\x02\x05\x01\x12\
    \x03\x0e\x08\x12\n\x0c\n\x05\x06\0\x02\x05\x02\x12\x03\x0e\x14!\n\x0c\n\
    \x05\x06\0\x02\x05\x03\x12\x03\x0e,;\n\x0b\n\x04\x06\0\x02\x06\x12\x03\
    \x0f\x043\n\x0c\n\x05\x06\0\x02\x06\x01\x12\x03\x0f\x08\x0e\n\x0c\n\x05\
    \x06\0\x02\x06\x02\x12\x03\x0f\x10\x19\n\x0c\n\x05\x06\0\x02\x06\x03\x12\
    \x03\x0f$/\n\x0b\n\x04\x06\0\x02\x07\x12\x03\x10\x049\n\x0c\n\x05\x06\0\
    \x02\x07\x01\x12\x03\x10\x08\x10\n\x0c\n\x05\x06\0\x02\x07\x02\x12\x03\
    \x10\x12\x1d\n\x0c\n\x05\x06\0\x02\x07\x03\x12\x03\x10(5\n\x0b\n\x04\x06\
    \0\x02\x08\x12\x03\x11\x040\n\x0c\n\x05\x06\0\x02\x08\x01\x12\x03\x11\
    \x08\r\n\x0c\n\x05\x06\0\x02\x08\x02\x12\x03\x11\x0f\x17\n\x0c\n\x05\x06\
    \0\x02\x08\x03\x12\x03\x11\",\n\x0b\n\x04\x06\0\x02\t\x12\x03\x12\x043\n\
    \x0c\n\x05\x06\0\x02\t\x01\x12\x03\x12\x08\x0e\n\x0c\n\x05\x06\0\x02\t\
    \x02\x12\x03\x12\x10\x19\n\x0c\n\x05\x06\0\x02\t\x03\x12\x03\x12$/\n\x0b\
    \n\x04\x06\0\x02\n\x12\x03\x13\x043\n\x0c\n\x05\x06\0\x02\n\x01\x12\x03\
    \x13\x08\x0e\n\x0c\n\x05\x06\0\x02\n\x02\x12\x03\x13\x10\x19\n\x0c\n\x05\
    \x06\0\x02\n\x03\x12\x03\x13$/\n\n\n\x02\x04\0\x12\x04\x16\0\x1f\x01\n\n\
    \n\x03\x04\0\x01\x12\x03\x16\x08\x11\n\x0b\n\x04\x04\0\x02\0\x12\x03\x17\
    \x04\x15\n\r\n\x05\x04\0\x02\0\x04\x12\x04\x17\x04\x16\x13\n\x0c\n\x05\
    \x04\0\x02\0\x05\x12\x03\x17\x04\n\n\x0c\n\x05\x04\0\x02\0\x01\x12\x03\
    \x17\x0b\x10\n\x0c\n\x05\x04\0\x02\0\x03\x12\x03\x17\x13\x14\n\x0b\n\x04\
    \x04\0\x02\x01\x12\x03\x18\x04\x14\n\r\n\x05\x04\0\x02\x01\x04\x12\x04\
    \x18\x04\x17\x15\n\x0c\n\x05\x04\0\x02\x01\x05\x12\x03\x18\x04\n\n\x0c\n\
    \x05\x04\0\x02\x01\x01\x12\x03\x18\x0b\x0f\n\x0c\n\x05\x04\0\x02\x01\x03\
    \x12\x03\x18\x12\x13\n\x0b\n\x04\x04\0\x02\x02\x12\x03\x19\x04\x15\n\r\n\
    \x05\x04\0\x02\x02\x04\x12\x04\x19\x04\x18\x14\n\x0c\n\x05\x04\0\x02\x02\
    \x05\x12\x03\x19\x04\n\n\x0c\n\x05\x04\0\x02\x02\x01\x12\x03\x19\x0b\x10\
    \n\x0c\n\x05\x04\0\x02\x02\x03\x12\x03\x19\x13\x14\n\x0b\n\x04\x04\0\x02\
    \x03\x12\x03\x1a\x04\x1b\n\r\n\x05\x04\0\x02\x03\x04\x12\x04\x1a\x04\x19\
    \x15\n\x0c\n\x05\x04\0\x02\x03\x05\x12\x03\x1a\x04\x08\n\x0c\n\x05\x04\0\
    \x02\x03\x01\x12\x03\x1a\t\x16\n\x0c\n\x05\x04\0\x02\x03\x03\x12\x03\x1a\
    \x19\x1a\n\x0b\n\x04\x04\0\x02\x04\x12\x03\x1b\x04\x1a\n\r\n\x05\x04\0\
    \x02\x04\x04\x12\x04\x1b\x04\x1a\x1b\n\x0c\n\x05\x04\0\x02\x04\x05\x12\
    \x03\x1b\x04\x08\n\x0c\n\x05\x04\0\x02\x04\x01\x12\x03\x1b\t\x15\n\x0c\n\
    \x05\x04\0\x02\x04\x03\x12\x03\x1b\x18\x19\n\x0b\n\x04\x04\0\x02\x05\x12\
    \x03\x1c\x04\x1b\n\r\n\x05\x04\0\x02\x05\x04\x12\x04\x1c\x04\x1b\x1a\n\
    \x0c\n\x05\x04\0\x02\x05\x05\x12\x03\x1c\x04\n\n\x0c\n\x05\x04\0\x02\x05\
    \x01\x12\x03\x1c\x0b\x16\n\x0c\n\x05\x04\0\x02\x05\x03\x12\x03\x1c\x19\
    \x1a\n\x0b\n\x04\x04\0\x02\x06\x12\x03\x1d\x04'\n\x0c\n\x05\x04\0\x02\
    \x06\x04\x12\x03\x1d\x04\x0c\n\x0c\n\x05\x04\0\x02\x06\x05\x12\x03\x1d\r\
    \x13\n\x0c\n\x05\x04\0\x02\x06\x01\x12\x03\x1d\x14\"\n\x0c\n\x05\x04\0\
    \x02\x06\x03\x12\x03\x1d%&\n\x0b\n\x04\x04\0\x02\x07\x12\x03\x1e\x04\x19\
    \n\r\n\x05\x04\0\x02\x07\x04\x12\x04\x1e\x04\x1d'\n\x0c\n\x05\x04\0\x02\
    \x07\x05\x12\x03\x1e\x04\n\n\x0c\n\x05\x04\0\x02\x07\x01\x12\x03\x1e\x0b\
    \x14\n\x0c\n\x05\x04\0\x02\x07\x03\x12\x03\x1e\x17\x18\n\n\n\x02\x04\x01\
    \x12\x04!\0&\x01\n\n\n\x03\x04\x01\x01\x12\x03!\x08\x13\n\x0b\n\x04\x04\
    \x01\x02\0\x12\x03\"\x04\"\n\r\n\x05\x04\x01\x02\0\x04\x12\x04\"\x04!\
    \x15\n\x0c\n\x05\x04\x01\x02\0\x06\x12\x03\"\x04\x17\n\x0c\n\x05\x04\x01\
    \x02\0\x01\x12\x03\"\x18\x1d\n\x0c\n\x05\x04\x01\x02\0\x03\x12\x03\"\x20\
    !\n\x0b\n\x04\x04\x01\x02\x01\x12\x03#\x04\x1d\n\r\n\x05\x04\x01\x02\x01\
    \x04\x12\x04#\x04\"\"\n\x0c\n\x05\x04\x01\x02\x01\x05\x12\x03#\x04\n\n\
    \x0c\n\x05\x04\x01\x02\x01\x01\x12\x03#\x0b\x18\n\x0c\n\x05\x04\x01\x02\
    \x01\x03\x12\x03#\x1b\x1c\n\x0b\n\x04\x04\x01\x02\x02\x12\x03$\x04\x1a\n\
    \r\n\x05\x04\x01\x02\x02\x04\x12\x04$\x04#\x1d\n\x0c\n\x05\x04\x01\x02\
    \x02\x05\x12\x03$\x04\t\n\x0c\n\x05\x04\x01\x02\x02\x01\x12\x03$\n\x15\n\
    \x0c\n\x05\x04\x01\x02\x02\x03\x12\x03$\x18\x19\n\x0b\n\x04\x04\x01\x02\
    \x03\x12\x03%\x04\x19\n\r\n\x05\x04\x01\x02\x03\x04\x12\x04%\x04$\x1a\n\
    \x0c\n\x05\x04\x01\x02\x03\x05\x12\x03%\x04\n\n\x0c\n\x05\x04\x01\x02\
    \x03\x01\x12\x03%\x0b\x14\n\x0c\n\x05\x04\x01\x02\x03\x03\x12\x03%\x17\
    \x18\n\n\n\x02\x04\x02\x12\x04(\0+\x01\n\n\n\x03\x04\x02\x01\x12\x03(\
    \x08\x0e\n\x0b\n\x04\x04\x02\x02\0\x12\x03)\x04\x12\n\r\n\x05\x04\x02\
    \x02\0\x04\x12\x04)\x04(\x10\n\x0c\n\x05\x04\x02\x02\0\x05\x12\x03)\x04\
    \n\n\x0c\n\x05\x04\x02\x02\0\x01\x12\x03)\x0b\r\n\x0c\n\x05\x04\x02\x02\
    \0\x03\x12\x03)\x10\x11\n\x0b\n\x04\x04\x02\x02\x01\x12\x03*\x04\x19\n\r\
    \n\x05\x04\x02\x02\x01\x04\x12\x04*\x04)\x12\n\x0c\n\x05\x04\x02\x02\x01\
    \x05\x12\x03*\x04\n\n\x0c\n\x05\x04\x02\x02\x01\x01\x12\x03*\x0b\x14\n\
    \x0c\n\x05\x04\x02\x02\x01\x03\x12\x03*\x17\x18\n\n\n\x02\x04\x03\x12\
    \x04-\02\x01\n\n\n\x03\x04\x03\x01\x12\x03-\x08\x10\n\x0b\n\x04\x04\x03\
    \x02\0\x12\x03.\x04\"\n\r\n\x05\x04\x03\x02\0\x04\x12\x04.\x04-\x12\n\
    \x0c\n\x05\x04\x03\x02\0\x06\x12\x03.\x04\x17\n\x0c\n\x05\x04\x03\x02\0\
    \x01\x12\x03.\x18\x1d\n\x0c\n\x05\x04\x03\x02\0\x03\x12\x03.\x20!\n\x0b\
    \n\x04\x04\x03\x02\x01\x12\x03/\x04\x13\n\r\n\x05\x04\x03\x02\x01\x04\
    \x12\x04/\x04.\"\n\x0c\n\x05\x04\x03\x02\x01\x05\x12\x03/\x04\n\n\x0c\n\
    \x05\x04\x03\x02\x01\x01\x12\x03/\x0b\x0e\n\x0c\n\x05\x04\x03\x02\x01\
    \x03\x12\x03/\x11\x12\n\x0b\n\x04\x04\x03\x02\x02\x12\x030\x04\x1a\n\r\n\
    \x05\x04\x03\x02\x02\x04\x12\x040\x04/\x13\n\x0c\n\x05\x04\x03\x02\x02\
    \x05\x12\x030\x04\t\n\x0c\n\x05\x04\x03\x02\x02\x01\x12\x030\n\x15\n\x0c\
    \n\x05\x04\x03\x02\x02\x03\x12\x030\x18\x19\n\x0b\n\x04\x04\x03\x02\x03\
    \x12\x031\x04\x19\n\r\n\x05\x04\x03\x02\x03\x04\x12\x041\x040\x1a\n\x0c\
    \n\x05\x04\x03\x02\x03\x05\x12\x031\x04\n\n\x0c\n\x05\x04\x03\x02\x03\
    \x01\x12\x031\x0b\x14\n\x0c\n\x05\x04\x03\x02\x03\x03\x12\x031\x17\x18\n\
    \n\n\x02\x04\x04\x12\x044\07\x01\n\n\n\x03\x04\x04\x01\x12\x034\x08\x0e\
    \n\x0b\n\x04\x04\x04\x02\0\x12\x035\x04\x13\n\r\n\x05\x04\x04\x02\0\x04\
    \x12\x045\x044\x10\n\x0c\n\x05\x04\x04\x02\0\x05\x12\x035\x04\n\n\x0c\n\
    \x05\x04\x04\x02\0\x01\x12\x035\x0b\x0e\n\x0c\n\x05\x04\x04\x02\0\x03\
    \x12\x035\x11\x12\n\x0b\n\x04\x04\x04\x02\x01\x12\x036\x04\x19\n\r\n\x05\
    \x04\x04\x02\x01\x04\x12\x046\x045\x13\n\x0c\n\x05\x04\x04\x02\x01\x05\
    \x12\x036\x04\n\n\x0c\n\x05\x04\x04\x02\x01\x01\x12\x036\x0b\x14\n\x0c\n\
    \x05\x04\x04\x02\x01\x03\x12\x036\x17\x18\n\n\n\x02\x04\x05\x12\x049\0=\
    \x01\n\n\n\x03\x04\x05\x01\x12\x039\x08\x10\n\x0b\n\x04\x04\x05\x02\0\
    \x12\x03:\x04\"\n\r\n\x05\x04\x05\x02\0\x04\x12\x04:\x049\x12\n\x0c\n\
    \x05\x04\x05\x02\0\x06\x12\x03:\x04\x17\n\x0c\n\x05\x04\x05\x02\0\x01\
    \x12\x03:\x18\x1d\n\x0c\n\x05\x04\x05\x02\0\x03\x12\x03:\x20!\n\x0b\n\
    \x04\x04\x05\x02\x01\x12\x03;\x04\x1a\n\r\n\x05\x04\x05\x02\x01\x04\x12\
    \x04;\x04:\"\n\x0c\n\x05\x04\x05\x02\x01\x05\x12\x03;\x04\t\n\x0c\n\x05\
    \x04\x05\x02\x01\x01\x12\x03;\n\x15\n\x0c\n\x05\x04\x05\x02\x01\x03\x12\
    \x03;\x18\x19\n\x0b\n\x04\x04\x05\x02\x02\x12\x03<\x04\x19\n\r\n\x05\x04\
    \x05\x02\x02\x04\x12\x04<\x04;\x1a\n\x0c\n\x05\x04\x05\x02\x02\x05\x12\
    \x03<\x04\n\n\x0c\n\x05\x04\x05\x02\x02\x01\x12\x03<\x0b\x14\n\x0c\n\x05\
    \x04\x05\x02\x02\x03\x12\x03<\x17\x18\n\n\n\x02\x04\x06\x12\x04?\0B\x01\
    \n\n\n\x03\x04\x06\x01\x12\x03?\x08\x11\n\x0b\n\x04\x04\x06\x02\0\x12\
    \x03@\x04\x12\n\r\n\x05\x04\x06\x02\0\x04\x12\x04@\x04?\x13\n\x0c\n\x05\
    \x04\x06\x02\0\x05\x12\x03@\x04\n\n\x0c\n\x05\x04\x06\x02\0\x01\x12\x03@\
    \x0b\r\n\x0c\n\x05\x04\x06\x02\0\x03\x12\x03@\x10\x11\n\x0b\n\x04\x04\
    \x06\x02\x01\x12\x03A\x04\x19\n\r\n\x05\x04\x06\x02\x01\x04\x12\x04A\x04\
    @\x12\n\x0c\n\x05\x04\x06\x02\x01\x05\x12\x03A\x04\n\n\x0c\n\x05\x04\x06\
    \x02\x01\x01\x12\x03A\x0b\x14\n\x0c\n\x05\x04\x06\x02\x01\x03\x12\x03A\
    \x17\x18\n\n\n\x02\x04\x07\x12\x04D\0H\x01\n\n\n\x03\x04\x07\x01\x12\x03\
    D\x08\x13\n\x0b\n\x04\x04\x07\x02\0\x12\x03E\x04\"\n\r\n\x05\x04\x07\x02\
    \0\x04\x12\x04E\x04D\x15\n\x0c\n\x05\x04\x07\x02\0\x06\x12\x03E\x04\x17\
    \n\x0c\n\x05\x04\x07\x02\0\x01\x12\x03E\x18\x1d\n\x0c\n\x05\x04\x07\x02\
    \0\x03\x12\x03E\x20!\n\x0b\n\x04\x04\x07\x02\x01\x12\x03F\x04\x1a\n\r\n\
    \x05\x04\x07\x02\x01\x04\x12\x04F\x04E\"\n\x0c\n\x05\x04\x07\x02\x01\x05\
    \x12\x03F\x04\t\n\x0c\n\x05\x04\x07\x02\x01\x01\x12\x03F\n\x15\n\x0c\n\
    \x05\x04\x07\x02\x01\x03\x12\x03F\x18\x19\n\x0b\n\x04\x04\x07\x02\x02\
    \x12\x03G\x04\x19\n\r\n\x05\x04\x07\x02\x02\x04\x12\x04G\x04F\x1a\n\x0c\
    \n\x05\x04\x07\x02\x02\x05\x12\x03G\x04\n\n\x0c\n\x05\x04\x07\x02\x02\
    \x01\x12\x03G\x0b\x14\n\x0c\n\x05\x04\x07\x02\x02\x03\x12\x03G\x17\x18\n\
    \n\n\x02\x04\x08\x12\x04J\0M\x01\n\n\n\x03\x04\x08\x01\x12\x03J\x08\x12\
    \n\x0b\n\x04\x04\x08\x02\0\x12\x03K\x04\x14\n\r\n\x05\x04\x08\x02\0\x04\
    \x12\x04K\x04J\x14\n\x0c\n\x05\x04\x08\x02\0\x05\x12\x03K\x04\n\n\x0c\n\
    \x05\x04\x08\x02\0\x01\x12\x03K\x0b\x0f\n\x0c\n\x05\x04\x08\x02\0\x03\
    \x12\x03K\x12\x13\n\x0b\n\x04\x04\x08\x02\x01\x12\x03L\x04\x19\n\r\n\x05\
    \x04\x08\x02\x01\x04\x12\x04L\x04K\x14\n\x0c\n\x05\x04\x08\x02\x01\x05\
    \x12\x03L\x04\n\n\x0c\n\x05\x04\x08\x02\x01\x01\x12\x03L\x0b\x14\n\x0c\n\
    \x05\x04\x08\x02\x01\x03\x12\x03L\x17\x18\n\n\n\x02\x04\t\x12\x04O\0S\
    \x01\n\n\n\x03\x04\t\x01\x12\x03O\x08\x14\n\x0b\n\x04\x04\t\x02\0\x12\
    \x03P\x04\"\n\r\n\x05\x04\t\x02\0\x04\x12\x04P\x04O\x16\n\x0c\n\x05\x04\
    \t\x02\0\x06\x12\x03P\x04\x17\n\x0c\n\x05\x04\t\x02\0\x01\x12\x03P\x18\
    \x1d\n\x0c\n\x05\x04\t\x02\0\x03\x12\x03P\x20!\n\x0b\n\x04\x04\t\x02\x01\
    \x12\x03Q\x04\x1a\n\r\n\x05\x04\t\x02\x01\x04\x12\x04Q\x04P\"\n\x0c\n\
    \x05\x04\t\x02\x01\x05\x12\x03Q\x04\t\n\x0c\n\x05\x04\t\x02\x01\x01\x12\
    \x03Q\n\x15\n\x0c\n\x05\x04\t\x02\x01\x03\x12\x03Q\x18\x19\n\x0b\n\x04\
    \x04\t\x02\x02\x12\x03R\x04\x19\n\r\n\x05\x04\t\x02\x02\x04\x12\x04R\x04\
    Q\x1a\n\x0c\n\x05\x04\t\x02\x02\x05\x12\x03R\x04\n\n\x0c\n\x05\x04\t\x02\
    \x02\x01\x12\x03R\x0b\x14\n\x0c\n\x05\x04\t\x02\x02\x03\x12\x03R\x17\x18\
    \n\n\n\x02\x04\n\x12\x04U\0X\x01\n\n\n\x03\x04\n\x01\x12\x03U\x08\x15\n\
    \x0b\n\x04\x04\n\x02\0\x12\x03V\x04\x14\n\r\n\x05\x04\n\x02\0\x04\x12\
    \x04V\x04U\x17\n\x0c\n\x05\x04\n\x02\0\x05\x12\x03V\x04\n\n\x0c\n\x05\
    \x04\n\x02\0\x01\x12\x03V\x0b\x0f\n\x0c\n\x05\x04\n\x02\0\x03\x12\x03V\
    \x12\x13\n\x0b\n\x04\x04\n\x02\x01\x12\x03W\x04\x19\n\r\n\x05\x04\n\x02\
    \x01\x04\x12\x04W\x04V\x14\n\x0c\n\x05\x04\n\x02\x01\x05\x12\x03W\x04\n\
    \n\x0c\n\x05\x04\n\x02\x01\x01\x12\x03W\x0b\x14\n\x0c\n\x05\x04\n\x02\
    \x01\x03\x12\x03W\x17\x18\n\n\n\x02\x04\x0b\x12\x04Z\0^\x01\n\n\n\x03\
    \x04\x0b\x01\x12\x03Z\x08\x17\n\x0b\n\x04\x04\x0b\x02\0\x12\x03[\x04\"\n\
    \r\n\x05\x04\x0b\x02\0\x04\x12\x04[\x04Z\x19\n\x0c\n\x05\x04\x0b\x02\0\
    \x06\x12\x03[\x04\x17\n\x0c\n\x05\x04\x0b\x02\0\x01\x12\x03[\x18\x1d\n\
    \x0c\n\x05\x04\x0b\x02\0\x03\x12\x03[\x20!\n\x0b\n\x04\x04\x0b\x02\x01\
    \x12\x03\\\x04\x1a\n\r\n\x05\x04\x0b\x02\x01\x04\x12\x04\\\x04[\"\n\x0c\
    \n\x05\x04\x0b\x02\x01\x05\x12\x03\\\x04\t\n\x0c\n\x05\x04\x0b\x02\x01\
    \x01\x12\x03\\\n\x15\n\x0c\n\x05\x04\x0b\x02\x01\x03\x12\x03\\\x18\x19\n\
    \x0b\n\x04\x04\x0b\x02\x02\x12\x03]\x04\x19\n\r\n\x05\x04\x0b\x02\x02\
    \x04\x12\x04]\x04\\\x1a\n\x0c\n\x05\x04\x0b\x02\x02\x05\x12\x03]\x04\n\n\
    \x0c\n\x05\x04\x0b\x02\x02\x01\x12\x03]\x0b\x14\n\x0c\n\x05\x04\x0b\x02\
    \x02\x03\x12\x03]\x17\x18\n\n\n\x02\x04\x0c\x12\x04`\0b\x01\n\n\n\x03\
    \x04\x0c\x01\x12\x03`\x08\x11\n\x0b\n\x04\x04\x0c\x02\0\x12\x03a\x04\x19\
    \n\r\n\x05\x04\x0c\x02\0\x04\x12\x04a\x04`\x13\n\x0c\n\x05\x04\x0c\x02\0\
    \x05\x12\x03a\x04\n\n\x0c\n\x05\x04\x0c\x02\0\x01\x12\x03a\x0b\x14\n\x0c\
    \n\x05\x04\x0c\x02\0\x03\x12\x03a\x17\x18\n\n\n\x02\x04\r\x12\x04d\0h\
    \x01\n\n\n\x03\x04\r\x01\x12\x03d\x08\x13\n\x0b\n\x04\x04\r\x02\0\x12\
    \x03e\x04\"\n\r\n\x05\x04\r\x02\0\x04\x12\x04e\x04d\x15\n\x0c\n\x05\x04\
    \r\x02\0\x06\x12\x03e\x04\x17\n\x0c\n\x05\x04\r\x02\0\x01\x12\x03e\x18\
    \x1d\n\x0c\n\x05\x04\r\x02\0\x03\x12\x03e\x20!\n\x0b\n\x04\x04\r\x02\x01\
    \x12\x03f\x04\x1a\n\r\n\x05\x04\r\x02\x01\x04\x12\x04f\x04e\"\n\x0c\n\
    \x05\x04\r\x02\x01\x05\x12\x03f\x04\t\n\x0c\n\x05\x04\r\x02\x01\x01\x12\
    \x03f\n\x15\n\x0c\n\x05\x04\r\x02\x01\x03\x12\x03f\x18\x19\n\x0b\n\x04\
    \x04\r\x02\x02\x12\x03g\x04\x19\n\r\n\x05\x04\r\x02\x02\x04\x12\x04g\x04\
    f\x1a\n\x0c\n\x05\x04\r\x02\x02\x05\x12\x03g\x04\n\n\x0c\n\x05\x04\r\x02\
    \x02\x01\x12\x03g\x0b\x14\n\x0c\n\x05\x04\r\x02\x02\x03\x12\x03g\x17\x18\
    \n\n\n\x02\x04\x0e\x12\x04j\0l\x01\n\n\n\x03\x04\x0e\x01\x12\x03j\x08\
    \x13\n\x0b\n\x04\x04\x0e\x02\0\x12\x03k\x04\x19\n\r\n\x05\x04\x0e\x02\0\
    \x04\x12\x04k\x04j\x15\n\x0c\n\x05\x04\x0e\x02\0\x05\x12\x03k\x04\n\n\
    \x0c\n\x05\x04\x0e\x02\0\x01\x12\x03k\x0b\x14\n\x0c\n\x05\x04\x0e\x02\0\
    \x03\x12\x03k\x17\x18\n\n\n\x02\x04\x0f\x12\x04n\0r\x01\n\n\n\x03\x04\
    \x0f\x01\x12\x03n\x08\x15\n\x0b\n\x04\x04\x0f\x02\0\x12\x03o\x04\"\n\r\n\
    \x05\x04\x0f\x02\0\x04\x12\x04o\x04n\x17\n\x0c\n\x05\x04\x0f\x02\0\x06\
    \x12\x03o\x04\x17\n\x0c\n\x05\x04\x0f\x02\0\x01\x12\x03o\x18\x1d\n\x0c\n\
    \x05\x04\x0f\x02\0\x03\x12\x03o\x20!\n\x0b\n\x04\x04\x0f\x02\x01\x12\x03\
    p\x04\x1a\n\r\n\x05\x04\x0f\x02\x01\x04\x12\x04p\x04o\"\n\x0c\n\x05\x04\
    \x0f\x02\x01\x05\x12\x03p\x04\t\n\x0c\n\x05\x04\x0f\x02\x01\x01\x12\x03p\
    \n\x15\n\x0c\n\x05\x04\x0f\x02\x01\x03\x12\x03p\x18\x19\n\x0b\n\x04\x04\
    \x0f\x02\x02\x12\x03q\x04\x19\n\r\n\x05\x04\x0f\x02\x02\x04\x12\x04q\x04\
    p\x1a\n\x0c\n\x05\x04\x0f\x02\x02\x05\x12\x03q\x04\n\n\x0c\n\x05\x04\x0f\
    \x02\x02\x01\x12\x03q\x0b\x14\n\x0c\n\x05\x04\x0f\x02\x02\x03\x12\x03q\
    \x17\x18\n\n\n\x02\x04\x10\x12\x04t\0v\x01\n\n\n\x03\x04\x10\x01\x12\x03\
    t\x08\x10\n\x0b\n\x04\x04\x10\x02\0\x12\x03u\x04\x19\n\r\n\x05\x04\x10\
    \x02\0\x04\x12\x04u\x04t\x12\n\x0c\n\x05\x04\x10\x02\0\x05\x12\x03u\x04\
    \n\n\x0c\n\x05\x04\x10\x02\0\x01\x12\x03u\x0b\x14\n\x0c\n\x05\x04\x10\
    \x02\0\x03\x12\x03u\x17\x18\n\n\n\x02\x04\x11\x12\x04x\0|\x01\n\n\n\x03\
    \x04\x11\x01\x12\x03x\x08\x12\n\x0b\n\x04\x04\x11\x02\0\x12\x03y\x04\"\n\
    \r\n\x05\x04\x11\x02\0\x04\x12\x04y\x04x\x14\n\x0c\n\x05\x04\x11\x02\0\
    \x06\x12\x03y\x04\x17\n\x0c\n\x05\x04\x11\x02\0\x01\x12\x03y\x18\x1d\n\
    \x0c\n\x05\x04\x11\x02\0\x03\x12\x03y\x20!\n\x0b\n\x04\x04\x11\x02\x01\
    \x12\x03z\x04\x1a\n\r\n\x05\x04\x11\x02\x01\x04\x12\x04z\x04y\"\n\x0c\n\
    \x05\x04\x11\x02\x01\x05\x12\x03z\x04\t\n\x0c\n\x05\x04\x11\x02\x01\x01\
    \x12\x03z\n\x15\n\x0c\n\x05\x04\x11\x02\x01\x03\x12\x03z\x18\x19\n\x0b\n\
    \x04\x04\x11\x02\x02\x12\x03{\x04\x19\n\r\n\x05\x04\x11\x02\x02\x04\x12\
    \x04{\x04z\x1a\n\x0c\n\x05\x04\x11\x02\x02\x05\x12\x03{\x04\n\n\x0c\n\
    \x05\x04\x11\x02\x02\x01\x12\x03{\x0b\x14\n\x0c\n\x05\x04\x11\x02\x02\
    \x03\x12\x03{\x17\x18\n\x0b\n\x02\x04\x12\x12\x05~\0\x81\x01\x01\n\n\n\
    \x03\x04\x12\x01\x12\x03~\x08\x11\n\x0b\n\x04\x04\x12\x02\0\x12\x03\x7f\
    \x04\x19\n\r\n\x05\x04\x12\x02\0\x04\x12\x04\x7f\x04~\x13\n\x0c\n\x05\
    \x04\x12\x02\0\x05\x12\x03\x7f\x04\n\n\x0c\n\x05\x04\x12\x02\0\x01\x12\
    \x03\x7f\x0b\x14\n\x0c\n\x05\x04\x12\x02\0\x03\x12\x03\x7f\x17\x18\n\x0c\
    \n\x04\x04\x12\x02\x01\x12\x04\x80\x01\x04\x13\n\x0e\n\x05\x04\x12\x02\
    \x01\x04\x12\x05\x80\x01\x04\x7f\x19\n\r\n\x05\x04\x12\x02\x01\x05\x12\
    \x04\x80\x01\x04\n\n\r\n\x05\x04\x12\x02\x01\x01\x12\x04\x80\x01\x0b\x0e\
    \n\r\n\x05\x04\x12\x02\x01\x03\x12\x04\x80\x01\x11\x12\n\x0c\n\x02\x04\
    \x13\x12\x06\x83\x01\0\x88\x01\x01\n\x0b\n\x03\x04\x13\x01\x12\x04\x83\
    \x01\x08\x13\n\x0c\n\x04\x04\x13\x02\0\x12\x04\x84\x01\x04\"\n\x0f\n\x05\
    \x04\x13\x02\0\x04\x12\x06\x84\x01\x04\x83\x01\x15\n\r\n\x05\x04\x13\x02\
    \0\x06\x12\x04\x84\x01\x04\x17\n\r\n\x05\x04\x13\x02\0\x01\x12\x04\x84\
    \x01\x18\x1d\n\r\n\x05\x04\x13\x02\0\x03\x12\x04\x84\x01\x20!\n\x0c\n\
    \x04\x04\x13\x02\x01\x12\x04\x85\x01\x04\x16\n\x0f\n\x05\x04\x13\x02\x01\
    \x04\x12\x06\x85\x01\x04\x84\x01\"\n\r\n\x05\x04\x13\x02\x01\x05\x12\x04\
    \x85\x01\x04\n\n\r\n\x05\x04\x13\x02\x01\x01\x12\x04\x85\x01\x0b\x11\n\r\
    \n\x05\x04\x13\x02\x01\x03\x12\x04\x85\x01\x14\x15\n\x0c\n\x04\x04\x13\
    \x02\x02\x12\x04\x86\x01\x04\x1a\n\x0f\n\x05\x04\x13\x02\x02\x04\x12\x06\
    \x86\x01\x04\x85\x01\x16\n\r\n\x05\x04\x13\x02\x02\x05\x12\x04\x86\x01\
    \x04\t\n\r\n\x05\x04\x13\x02\x02\x01\x12\x04\x86\x01\n\x15\n\r\n\x05\x04\
    \x13\x02\x02\x03\x12\x04\x86\x01\x18\x19\n\x0c\n\x04\x04\x13\x02\x03\x12\
    \x04\x87\x01\x04\x19\n\x0f\n\x05\x04\x13\x02\x03\x04\x12\x06\x87\x01\x04\
    \x86\x01\x1a\n\r\n\x05\x04\x13\x02\x03\x05\x12\x04\x87\x01\x04\n\n\r\n\
    \x05\x04\x13\x02\x03\x01\x12\x04\x87\x01\x0b\x14\n\r\n\x05\x04\x13\x02\
    \x03\x03\x12\x04\x87\x01\x17\x18\n\x0c\n\x02\x04\x14\x12\x06\x8a\x01\0\
    \x8c\x01\x01\n\x0b\n\x03\x04\x14\x01\x12\x04\x8a\x01\x08\x11\n\x0c\n\x04\
    \x04\x14\x02\0\x12\x04\x8b\x01\x04\x19\n\x0f\n\x05\x04\x14\x02\0\x04\x12\
    \x06\x8b\x01\x04\x8a\x01\x13\n\r\n\x05\x04\x14\x02\0\x05\x12\x04\x8b\x01\
    \x04\n\n\r\n\x05\x04\x14\x02\0\x01\x12\x04\x8b\x01\x0b\x14\n\r\n\x05\x04\
    \x14\x02\0\x03\x12\x04\x8b\x01\x17\x18\n\x0c\n\x02\x04\x15\x12\x06\x8e\
    \x01\0\x93\x01\x01\n\x0b\n\x03\x04\x15\x01\x12\x04\x8e\x01\x08\x13\n\x0c\
    \n\x04\x04\x15\x02\0\x12\x04\x8f\x01\x04\"\n\x0f\n\x05\x04\x15\x02\0\x04\
    \x12\x06\x8f\x01\x04\x8e\x01\x15\n\r\n\x05\x04\x15\x02\0\x06\x12\x04\x8f\
    \x01\x04\x17\n\r\n\x05\x04\x15\x02\0\x01\x12\x04\x8f\x01\x18\x1d\n\r\n\
    \x05\x04\x15\x02\0\x03\x12\x04\x8f\x01\x20!\n\x0c\n\x04\x04\x15\x02\x01\
    \x12\x04\x90\x01\x04\x16\n\x0f\n\x05\x04\x15\x02\x01\x04\x12\x06\x90\x01\
    \x04\x8f\x01\"\n\r\n\x05\x04\x15\x02\x01\x05\x12\x04\x90\x01\x04\n\n\r\n\
    \x05\x04\x15\x02\x01\x01\x12\x04\x90\x01\x0b\x11\n\r\n\x05\x04\x15\x02\
    \x01\x03\x12\x04\x90\x01\x14\x15\n\x0c\n\x04\x04\x15\x02\x02\x12\x04\x91\
    \x01\x04\x1a\n\x0f\n\x05\x04\x15\x02\x02\x04\x12\x06\x91\x01\x04\x90\x01\
    \x16\n\r\n\x05\x04\x15\x02\x02\x05\x12\x04\x91\x01\x04\t\n\r\n\x05\x04\
    \x15\x02\x02\x01\x12\x04\x91\x01\n\x15\n\r\n\x05\x04\x15\x02\x02\x03\x12\
    \x04\x91\x01\x18\x19\n\x0c\n\x04\x04\x15\x02\x03\x12\x04\x92\x01\x04\x19\
    \n\x0f\n\x05\x04\x15\x02\x03\x04\x12\x06\x92\x01\x04\x91\x01\x1a\n\r\n\
    \x05\x04\x15\x02\x03\x05\x12\x04\x92\x01\x04\n\n\r\n\x05\x04\x15\x02\x03\
    \x01\x12\x04\x92\x01\x0b\x14\n\r\n\x05\x04\x15\x02\x03\x03\x12\x04\x92\
    \x01\x17\x18b\x06proto3\
";

static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;

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 {
    file_descriptor_proto_lazy.get(|| {
        parse_descriptor_proto()
    })
}