dgraph 0.4.0

// This file is generated by rust-protobuf 2.16.2. 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 `api.proto`

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

#[derive(PartialEq, Clone, Default)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct Request {
    // message fields
    pub start_ts: u64,
    pub query: ::std::string::String,
    pub vars: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
    pub read_only: bool,
    pub best_effort: bool,
    pub mutations: ::protobuf::RepeatedField<Mutation>,
    pub commit_now: bool,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // uint64 start_ts = 1;

    pub fn get_start_ts(&self) -> u64 {
        self.start_ts
    }
    pub fn clear_start_ts(&mut self) {
        self.start_ts = 0;
    }

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

    // string query = 4;

    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())
    }

    // repeated .api.Request.VarsEntry vars = 5;

    pub fn get_vars(
        &self,
    ) -> &::std::collections::HashMap<::std::string::String, ::std::string::String> {
        &self.vars
    }
    pub fn clear_vars(&mut self) {
        self.vars.clear();
    }

    // Param is passed by value, moved
    pub fn set_vars(
        &mut self,
        v: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
    ) {
        self.vars = v;
    }

    // Mutable pointer to the field.
    pub fn mut_vars(
        &mut self,
    ) -> &mut ::std::collections::HashMap<::std::string::String, ::std::string::String> {
        &mut self.vars
    }

    // Take field
    pub fn take_vars(
        &mut self,
    ) -> ::std::collections::HashMap<::std::string::String, ::std::string::String> {
        ::std::mem::replace(&mut self.vars, ::std::collections::HashMap::new())
    }

    // bool read_only = 6;

    pub fn get_read_only(&self) -> bool {
        self.read_only
    }
    pub fn clear_read_only(&mut self) {
        self.read_only = false;
    }

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

    // bool best_effort = 7;

    pub fn get_best_effort(&self) -> bool {
        self.best_effort
    }
    pub fn clear_best_effort(&mut self) {
        self.best_effort = false;
    }

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

    // repeated .api.Mutation mutations = 12;

    pub fn get_mutations(&self) -> &[Mutation] {
        &self.mutations
    }
    pub fn clear_mutations(&mut self) {
        self.mutations.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_mutations(&mut self) -> &mut ::protobuf::RepeatedField<Mutation> {
        &mut self.mutations
    }

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

    // bool commit_now = 13;

    pub fn get_commit_now(&self) -> bool {
        self.commit_now
    }
    pub fn clear_commit_now(&mut self) {
        self.commit_now = false;
    }

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

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

    fn merge_from(
        &mut self,
        is: &mut ::protobuf::CodedInputStream<'_>,
    ) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(
                            wire_type,
                        ));
                    }
                    let tmp = is.read_uint64()?;
                    self.start_ts = tmp;
                }
                4 => {
                    ::protobuf::rt::read_singular_proto3_string_into(
                        wire_type,
                        is,
                        &mut self.query,
                    )?;
                }
                5 => {
                    ::protobuf::rt::read_map_into::<
                        ::protobuf::types::ProtobufTypeString,
                        ::protobuf::types::ProtobufTypeString,
                    >(wire_type, is, &mut self.vars)?;
                }
                6 => {
                    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.read_only = tmp;
                }
                7 => {
                    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.best_effort = tmp;
                }
                12 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.mutations)?;
                }
                13 => {
                    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.commit_now = 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.start_ts != 0 {
            my_size += ::protobuf::rt::value_size(
                1,
                self.start_ts,
                ::protobuf::wire_format::WireTypeVarint,
            );
        }
        if !self.query.is_empty() {
            my_size += ::protobuf::rt::string_size(4, &self.query);
        }
        my_size += ::protobuf::rt::compute_map_size::<
            ::protobuf::types::ProtobufTypeString,
            ::protobuf::types::ProtobufTypeString,
        >(5, &self.vars);
        if self.read_only != false {
            my_size += 2;
        }
        if self.best_effort != false {
            my_size += 2;
        }
        for value in &self.mutations {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if self.commit_now != false {
            my_size += 2;
        }
        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.start_ts != 0 {
            os.write_uint64(1, self.start_ts)?;
        }
        if !self.query.is_empty() {
            os.write_string(4, &self.query)?;
        }
        ::protobuf::rt::write_map_with_cached_sizes::<
            ::protobuf::types::ProtobufTypeString,
            ::protobuf::types::ProtobufTypeString,
        >(5, &self.vars, os)?;
        if self.read_only != false {
            os.write_bool(6, self.read_only)?;
        }
        if self.best_effort != false {
            os.write_bool(7, self.best_effort)?;
        }
        for v in &self.mutations {
            os.write_tag(12, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if self.commit_now != false {
            os.write_bool(13, self.commit_now)?;
        }
        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() -> Request {
        Request::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,
            >(
                "start_ts",
                |m: &Request| &m.start_ts,
                |m: &mut Request| &mut m.start_ts,
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<
                _,
                ::protobuf::types::ProtobufTypeString,
            >(
                "query",
                |m: &Request| &m.query,
                |m: &mut Request| &mut m.query,
            ));
            fields.push(::protobuf::reflect::accessor::make_map_accessor::<
                _,
                ::protobuf::types::ProtobufTypeString,
                ::protobuf::types::ProtobufTypeString,
            >(
                "vars",
                |m: &Request| &m.vars,
                |m: &mut Request| &mut m.vars,
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<
                _,
                ::protobuf::types::ProtobufTypeBool,
            >(
                "read_only",
                |m: &Request| &m.read_only,
                |m: &mut Request| &mut m.read_only,
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<
                _,
                ::protobuf::types::ProtobufTypeBool,
            >(
                "best_effort",
                |m: &Request| &m.best_effort,
                |m: &mut Request| &mut m.best_effort,
            ));
            fields.push(
                ::protobuf::reflect::accessor::make_repeated_field_accessor::<
                    _,
                    ::protobuf::types::ProtobufTypeMessage<Mutation>,
                >(
                    "mutations",
                    |m: &Request| &m.mutations,
                    |m: &mut Request| &mut m.mutations,
                ),
            );
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<
                _,
                ::protobuf::types::ProtobufTypeBool,
            >(
                "commit_now",
                |m: &Request| &m.commit_now,
                |m: &mut Request| &mut m.commit_now,
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Request>(
                "Request",
                fields,
                file_descriptor_proto(),
            )
        })
    }

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

impl ::protobuf::Clear for Request {
    fn clear(&mut self) {
        self.start_ts = 0;
        self.query.clear();
        self.vars.clear();
        self.read_only = false;
        self.best_effort = false;
        self.mutations.clear();
        self.commit_now = false;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq, Clone, Default)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct Uids {
    // message fields
    pub uids: ::protobuf::RepeatedField<::std::string::String>,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // repeated string uids = 1;

    pub fn get_uids(&self) -> &[::std::string::String] {
        &self.uids
    }
    pub fn clear_uids(&mut self) {
        self.uids.clear();
    }

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

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

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

impl ::protobuf::Message for Uids {
    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_repeated_string_into(wire_type, is, &mut self.uids)?;
                }
                _ => {
                    ::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;
        for value in &self.uids {
            my_size += ::protobuf::rt::string_size(1, &value);
        }
        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<()> {
        for v in &self.uids {
            os.write_string(1, &v)?;
        }
        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() -> Uids {
        Uids::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_repeated_field_accessor::<
                    _,
                    ::protobuf::types::ProtobufTypeString,
                >("uids", |m: &Uids| &m.uids, |m: &mut Uids| &mut m.uids),
            );
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Uids>(
                "Uids",
                fields,
                file_descriptor_proto(),
            )
        })
    }

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

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

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

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

#[derive(PartialEq, Clone, Default)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct Response {
    // message fields
    pub json: ::std::vec::Vec<u8>,
    pub txn: ::protobuf::SingularPtrField<TxnContext>,
    pub latency: ::protobuf::SingularPtrField<Latency>,
    pub metrics: ::protobuf::SingularPtrField<Metrics>,
    pub uids: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // bytes json = 1;

    pub fn get_json(&self) -> &[u8] {
        &self.json
    }
    pub fn clear_json(&mut self) {
        self.json.clear();
    }

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

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

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

    // .api.TxnContext txn = 2;

    pub fn get_txn(&self) -> &TxnContext {
        self.txn
            .as_ref()
            .unwrap_or_else(|| <TxnContext as ::protobuf::Message>::default_instance())
    }
    pub fn clear_txn(&mut self) {
        self.txn.clear();
    }

    pub fn has_txn(&self) -> bool {
        self.txn.is_some()
    }

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

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

    // Take field
    pub fn take_txn(&mut self) -> TxnContext {
        self.txn.take().unwrap_or_else(|| TxnContext::new())
    }

    // .api.Latency latency = 3;

    pub fn get_latency(&self) -> &Latency {
        self.latency
            .as_ref()
            .unwrap_or_else(|| <Latency as ::protobuf::Message>::default_instance())
    }
    pub fn clear_latency(&mut self) {
        self.latency.clear();
    }

    pub fn has_latency(&self) -> bool {
        self.latency.is_some()
    }

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

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

    // Take field
    pub fn take_latency(&mut self) -> Latency {
        self.latency.take().unwrap_or_else(|| Latency::new())
    }

    // .api.Metrics metrics = 4;

    pub fn get_metrics(&self) -> &Metrics {
        self.metrics
            .as_ref()
            .unwrap_or_else(|| <Metrics as ::protobuf::Message>::default_instance())
    }
    pub fn clear_metrics(&mut self) {
        self.metrics.clear();
    }

    pub fn has_metrics(&self) -> bool {
        self.metrics.is_some()
    }

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

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

    // Take field
    pub fn take_metrics(&mut self) -> Metrics {
        self.metrics.take().unwrap_or_else(|| Metrics::new())
    }

    // repeated .api.Response.UidsEntry uids = 12;

    pub fn get_uids(
        &self,
    ) -> &::std::collections::HashMap<::std::string::String, ::std::string::String> {
        &self.uids
    }
    pub fn clear_uids(&mut self) {
        self.uids.clear();
    }

    // Param is passed by value, moved
    pub fn set_uids(
        &mut self,
        v: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
    ) {
        self.uids = v;
    }

    // Mutable pointer to the field.
    pub fn mut_uids(
        &mut self,
    ) -> &mut ::std::collections::HashMap<::std::string::String, ::std::string::String> {
        &mut self.uids
    }

    // Take field
    pub fn take_uids(
        &mut self,
    ) -> ::std::collections::HashMap<::std::string::String, ::std::string::String> {
        ::std::mem::replace(&mut self.uids, ::std::collections::HashMap::new())
    }
}

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

    fn merge_from(
        &mut self,
        is: &mut ::protobuf::CodedInputStream<'_>,
    ) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.json)?;
                }
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.txn)?;
                }
                3 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.latency)?;
                }
                4 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.metrics)?;
                }
                12 => {
                    ::protobuf::rt::read_map_into::<
                        ::protobuf::types::ProtobufTypeString,
                        ::protobuf::types::ProtobufTypeString,
                    >(wire_type, is, &mut self.uids)?;
                }
                _ => {
                    ::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.json.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.json);
        }
        if let Some(ref v) = self.txn.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.latency.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.metrics.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        my_size += ::protobuf::rt::compute_map_size::<
            ::protobuf::types::ProtobufTypeString,
            ::protobuf::types::ProtobufTypeString,
        >(12, &self.uids);
        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.json.is_empty() {
            os.write_bytes(1, &self.json)?;
        }
        if let Some(ref v) = self.txn.as_ref() {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.latency.as_ref() {
            os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.metrics.as_ref() {
            os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        ::protobuf::rt::write_map_with_cached_sizes::<
            ::protobuf::types::ProtobufTypeString,
            ::protobuf::types::ProtobufTypeString,
        >(12, &self.uids, os)?;
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

    fn new() -> Response {
        Response::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::ProtobufTypeBytes,
            >(
                "json",
                |m: &Response| &m.json,
                |m: &mut Response| &mut m.json,
            ));
            fields.push(
                ::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<
                    _,
                    ::protobuf::types::ProtobufTypeMessage<TxnContext>,
                >("txn", |m: &Response| &m.txn, |m: &mut Response| &mut m.txn),
            );
            fields.push(
                ::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<
                    _,
                    ::protobuf::types::ProtobufTypeMessage<Latency>,
                >(
                    "latency",
                    |m: &Response| &m.latency,
                    |m: &mut Response| &mut m.latency,
                ),
            );
            fields.push(
                ::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<
                    _,
                    ::protobuf::types::ProtobufTypeMessage<Metrics>,
                >(
                    "metrics",
                    |m: &Response| &m.metrics,
                    |m: &mut Response| &mut m.metrics,
                ),
            );
            fields.push(::protobuf::reflect::accessor::make_map_accessor::<
                _,
                ::protobuf::types::ProtobufTypeString,
                ::protobuf::types::ProtobufTypeString,
            >(
                "uids",
                |m: &Response| &m.uids,
                |m: &mut Response| &mut m.uids,
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Response>(
                "Response",
                fields,
                file_descriptor_proto(),
            )
        })
    }

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

impl ::protobuf::Clear for Response {
    fn clear(&mut self) {
        self.json.clear();
        self.txn.clear();
        self.latency.clear();
        self.metrics.clear();
        self.uids.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq, Clone, Default)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct Mutation {
    // message fields
    pub set_json: ::std::vec::Vec<u8>,
    pub delete_json: ::std::vec::Vec<u8>,
    pub set_nquads: ::std::vec::Vec<u8>,
    pub del_nquads: ::std::vec::Vec<u8>,
    pub set: ::protobuf::RepeatedField<NQuad>,
    pub del: ::protobuf::RepeatedField<NQuad>,
    pub cond: ::std::string::String,
    pub commit_now: bool,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // bytes set_json = 1;

    pub fn get_set_json(&self) -> &[u8] {
        &self.set_json
    }
    pub fn clear_set_json(&mut self) {
        self.set_json.clear();
    }

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

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

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

    // bytes delete_json = 2;

    pub fn get_delete_json(&self) -> &[u8] {
        &self.delete_json
    }
    pub fn clear_delete_json(&mut self) {
        self.delete_json.clear();
    }

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

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

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

    // bytes set_nquads = 3;

    pub fn get_set_nquads(&self) -> &[u8] {
        &self.set_nquads
    }
    pub fn clear_set_nquads(&mut self) {
        self.set_nquads.clear();
    }

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

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

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

    // bytes del_nquads = 4;

    pub fn get_del_nquads(&self) -> &[u8] {
        &self.del_nquads
    }
    pub fn clear_del_nquads(&mut self) {
        self.del_nquads.clear();
    }

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

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

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

    // repeated .api.NQuad set = 5;

    pub fn get_set(&self) -> &[NQuad] {
        &self.set
    }
    pub fn clear_set(&mut self) {
        self.set.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_set(&mut self) -> &mut ::protobuf::RepeatedField<NQuad> {
        &mut self.set
    }

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

    // repeated .api.NQuad del = 6;

    pub fn get_del(&self) -> &[NQuad] {
        &self.del
    }
    pub fn clear_del(&mut self) {
        self.del.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_del(&mut self) -> &mut ::protobuf::RepeatedField<NQuad> {
        &mut self.del
    }

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

    // string cond = 9;

    pub fn get_cond(&self) -> &str {
        &self.cond
    }
    pub fn clear_cond(&mut self) {
        self.cond.clear();
    }

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

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

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

    // bool commit_now = 14;

    pub fn get_commit_now(&self) -> bool {
        self.commit_now
    }
    pub fn clear_commit_now(&mut self) {
        self.commit_now = false;
    }

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

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

    fn merge_from(
        &mut self,
        is: &mut ::protobuf::CodedInputStream<'_>,
    ) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(
                        wire_type,
                        is,
                        &mut self.set_json,
                    )?;
                }
                2 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(
                        wire_type,
                        is,
                        &mut self.delete_json,
                    )?;
                }
                3 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(
                        wire_type,
                        is,
                        &mut self.set_nquads,
                    )?;
                }
                4 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(
                        wire_type,
                        is,
                        &mut self.del_nquads,
                    )?;
                }
                5 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.set)?;
                }
                6 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.del)?;
                }
                9 => {
                    ::protobuf::rt::read_singular_proto3_string_into(
                        wire_type,
                        is,
                        &mut self.cond,
                    )?;
                }
                14 => {
                    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.commit_now = 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.set_json.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.set_json);
        }
        if !self.delete_json.is_empty() {
            my_size += ::protobuf::rt::bytes_size(2, &self.delete_json);
        }
        if !self.set_nquads.is_empty() {
            my_size += ::protobuf::rt::bytes_size(3, &self.set_nquads);
        }
        if !self.del_nquads.is_empty() {
            my_size += ::protobuf::rt::bytes_size(4, &self.del_nquads);
        }
        for value in &self.set {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        for value in &self.del {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if !self.cond.is_empty() {
            my_size += ::protobuf::rt::string_size(9, &self.cond);
        }
        if self.commit_now != false {
            my_size += 2;
        }
        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.set_json.is_empty() {
            os.write_bytes(1, &self.set_json)?;
        }
        if !self.delete_json.is_empty() {
            os.write_bytes(2, &self.delete_json)?;
        }
        if !self.set_nquads.is_empty() {
            os.write_bytes(3, &self.set_nquads)?;
        }
        if !self.del_nquads.is_empty() {
            os.write_bytes(4, &self.del_nquads)?;
        }
        for v in &self.set {
            os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        for v in &self.del {
            os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if !self.cond.is_empty() {
            os.write_string(9, &self.cond)?;
        }
        if self.commit_now != false {
            os.write_bool(14, self.commit_now)?;
        }
        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() -> Mutation {
        Mutation::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::ProtobufTypeBytes,
            >(
                "set_json",
                |m: &Mutation| &m.set_json,
                |m: &mut Mutation| &mut m.set_json,
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<
                _,
                ::protobuf::types::ProtobufTypeBytes,
            >(
                "delete_json",
                |m: &Mutation| &m.delete_json,
                |m: &mut Mutation| &mut m.delete_json,
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<
                _,
                ::protobuf::types::ProtobufTypeBytes,
            >(
                "set_nquads",
                |m: &Mutation| &m.set_nquads,
                |m: &mut Mutation| &mut m.set_nquads,
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<
                _,
                ::protobuf::types::ProtobufTypeBytes,
            >(
                "del_nquads",
                |m: &Mutation| &m.del_nquads,
                |m: &mut Mutation| &mut m.del_nquads,
            ));
            fields.push(
                ::protobuf::reflect::accessor::make_repeated_field_accessor::<
                    _,
                    ::protobuf::types::ProtobufTypeMessage<NQuad>,
                >("set", |m: &Mutation| &m.set, |m: &mut Mutation| &mut m.set),
            );
            fields.push(
                ::protobuf::reflect::accessor::make_repeated_field_accessor::<
                    _,
                    ::protobuf::types::ProtobufTypeMessage<NQuad>,
                >("del", |m: &Mutation| &m.del, |m: &mut Mutation| &mut m.del),
            );
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<
                _,
                ::protobuf::types::ProtobufTypeString,
            >(
                "cond",
                |m: &Mutation| &m.cond,
                |m: &mut Mutation| &mut m.cond,
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<
                _,
                ::protobuf::types::ProtobufTypeBool,
            >(
                "commit_now",
                |m: &Mutation| &m.commit_now,
                |m: &mut Mutation| &mut m.commit_now,
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Mutation>(
                "Mutation",
                fields,
                file_descriptor_proto(),
            )
        })
    }

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

impl ::protobuf::Clear for Mutation {
    fn clear(&mut self) {
        self.set_json.clear();
        self.delete_json.clear();
        self.set_nquads.clear();
        self.del_nquads.clear();
        self.set.clear();
        self.del.clear();
        self.cond.clear();
        self.commit_now = false;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq, Clone, Default)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct Operation {
    // message fields
    pub schema: ::std::string::String,
    pub drop_attr: ::std::string::String,
    pub drop_all: bool,
    pub drop_op: Operation_DropOp,
    pub drop_value: ::std::string::String,
    pub run_in_background: bool,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string schema = 1;

    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())
    }

    // string drop_attr = 2;

    pub fn get_drop_attr(&self) -> &str {
        &self.drop_attr
    }
    pub fn clear_drop_attr(&mut self) {
        self.drop_attr.clear();
    }

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

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

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

    // bool drop_all = 3;

    pub fn get_drop_all(&self) -> bool {
        self.drop_all
    }
    pub fn clear_drop_all(&mut self) {
        self.drop_all = false;
    }

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

    // .api.Operation.DropOp drop_op = 4;

    pub fn get_drop_op(&self) -> Operation_DropOp {
        self.drop_op
    }
    pub fn clear_drop_op(&mut self) {
        self.drop_op = Operation_DropOp::NONE;
    }

    // Param is passed by value, moved
    pub fn set_drop_op(&mut self, v: Operation_DropOp) {
        self.drop_op = v;
    }

    // string drop_value = 5;

    pub fn get_drop_value(&self) -> &str {
        &self.drop_value
    }
    pub fn clear_drop_value(&mut self) {
        self.drop_value.clear();
    }

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

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

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

    // bool run_in_background = 6;

    pub fn get_run_in_background(&self) -> bool {
        self.run_in_background
    }
    pub fn clear_run_in_background(&mut self) {
        self.run_in_background = false;
    }

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

impl ::protobuf::Message for Operation {
    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.schema,
                    )?;
                }
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(
                        wire_type,
                        is,
                        &mut self.drop_attr,
                    )?;
                }
                3 => {
                    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.drop_all = tmp;
                }
                4 => ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(
                    wire_type,
                    is,
                    &mut self.drop_op,
                    4,
                    &mut self.unknown_fields,
                )?,
                5 => {
                    ::protobuf::rt::read_singular_proto3_string_into(
                        wire_type,
                        is,
                        &mut self.drop_value,
                    )?;
                }
                6 => {
                    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.run_in_background = 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.schema.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.schema);
        }
        if !self.drop_attr.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.drop_attr);
        }
        if self.drop_all != false {
            my_size += 2;
        }
        if self.drop_op != Operation_DropOp::NONE {
            my_size += ::protobuf::rt::enum_size(4, self.drop_op);
        }
        if !self.drop_value.is_empty() {
            my_size += ::protobuf::rt::string_size(5, &self.drop_value);
        }
        if self.run_in_background != false {
            my_size += 2;
        }
        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.schema.is_empty() {
            os.write_string(1, &self.schema)?;
        }
        if !self.drop_attr.is_empty() {
            os.write_string(2, &self.drop_attr)?;
        }
        if self.drop_all != false {
            os.write_bool(3, self.drop_all)?;
        }
        if self.drop_op != Operation_DropOp::NONE {
            os.write_enum(4, ::protobuf::ProtobufEnum::value(&self.drop_op))?;
        }
        if !self.drop_value.is_empty() {
            os.write_string(5, &self.drop_value)?;
        }
        if self.run_in_background != false {
            os.write_bool(6, self.run_in_background)?;
        }
        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() -> Operation {
        Operation::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,
            >(
                "schema",
                |m: &Operation| &m.schema,
                |m: &mut Operation| &mut m.schema,
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<
                _,
                ::protobuf::types::ProtobufTypeString,
            >(
                "drop_attr",
                |m: &Operation| &m.drop_attr,
                |m: &mut Operation| &mut m.drop_attr,
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<
                _,
                ::protobuf::types::ProtobufTypeBool,
            >(
                "drop_all",
                |m: &Operation| &m.drop_all,
                |m: &mut Operation| &mut m.drop_all,
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<
                _,
                ::protobuf::types::ProtobufTypeEnum<Operation_DropOp>,
            >(
                "drop_op",
                |m: &Operation| &m.drop_op,
                |m: &mut Operation| &mut m.drop_op,
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<
                _,
                ::protobuf::types::ProtobufTypeString,
            >(
                "drop_value",
                |m: &Operation| &m.drop_value,
                |m: &mut Operation| &mut m.drop_value,
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<
                _,
                ::protobuf::types::ProtobufTypeBool,
            >(
                "run_in_background",
                |m: &Operation| &m.run_in_background,
                |m: &mut Operation| &mut m.run_in_background,
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Operation>(
                "Operation",
                fields,
                file_descriptor_proto(),
            )
        })
    }

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

impl ::protobuf::Clear for Operation {
    fn clear(&mut self) {
        self.schema.clear();
        self.drop_attr.clear();
        self.drop_all = false;
        self.drop_op = Operation_DropOp::NONE;
        self.drop_value.clear();
        self.run_in_background = false;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(Clone, PartialEq, Eq, Debug, Hash)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub enum Operation_DropOp {
    NONE = 0,
    ALL = 1,
    DATA = 2,
    ATTR = 3,
    TYPE = 4,
}

impl ::protobuf::ProtobufEnum for Operation_DropOp {
    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<Operation_DropOp> {
        match value {
            0 => ::std::option::Option::Some(Operation_DropOp::NONE),
            1 => ::std::option::Option::Some(Operation_DropOp::ALL),
            2 => ::std::option::Option::Some(Operation_DropOp::DATA),
            3 => ::std::option::Option::Some(Operation_DropOp::ATTR),
            4 => ::std::option::Option::Some(Operation_DropOp::TYPE),
            _ => ::std::option::Option::None,
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [Operation_DropOp] = &[
            Operation_DropOp::NONE,
            Operation_DropOp::ALL,
            Operation_DropOp::DATA,
            Operation_DropOp::ATTR,
            Operation_DropOp::TYPE,
        ];
        values
    }

    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> =
            ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            ::protobuf::reflect::EnumDescriptor::new_pb_name::<Operation_DropOp>(
                "Operation.DropOp",
                file_descriptor_proto(),
            )
        })
    }
}

impl ::std::marker::Copy for Operation_DropOp {}

impl ::std::default::Default for Operation_DropOp {
    fn default() -> Self {
        Operation_DropOp::NONE
    }
}

impl ::protobuf::reflect::ProtobufValue for Operation_DropOp {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
    }
}

#[derive(PartialEq, Clone, Default)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct Payload {
    // message fields
    pub Data: ::std::vec::Vec<u8>,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // bytes Data = 1;

    pub fn get_Data(&self) -> &[u8] {
        &self.Data
    }
    pub fn clear_Data(&mut self) {
        self.Data.clear();
    }

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

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

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

impl ::protobuf::Message for Payload {
    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_bytes_into(wire_type, is, &mut self.Data)?;
                }
                _ => {
                    ::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.Data.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.Data);
        }
        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.Data.is_empty() {
            os.write_bytes(1, &self.Data)?;
        }
        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() -> Payload {
        Payload::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::ProtobufTypeBytes,
            >(
                "Data",
                |m: &Payload| &m.Data,
                |m: &mut Payload| &mut m.Data,
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Payload>(
                "Payload",
                fields,
                file_descriptor_proto(),
            )
        })
    }

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

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

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

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

#[derive(PartialEq, Clone, Default)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct TxnContext {
    // message fields
    pub start_ts: u64,
    pub commit_ts: u64,
    pub aborted: bool,
    pub keys: ::protobuf::RepeatedField<::std::string::String>,
    pub preds: ::protobuf::RepeatedField<::std::string::String>,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // uint64 start_ts = 1;

    pub fn get_start_ts(&self) -> u64 {
        self.start_ts
    }
    pub fn clear_start_ts(&mut self) {
        self.start_ts = 0;
    }

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

    // uint64 commit_ts = 2;

    pub fn get_commit_ts(&self) -> u64 {
        self.commit_ts
    }
    pub fn clear_commit_ts(&mut self) {
        self.commit_ts = 0;
    }

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

    // bool aborted = 3;

    pub fn get_aborted(&self) -> bool {
        self.aborted
    }
    pub fn clear_aborted(&mut self) {
        self.aborted = false;
    }

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

    // repeated string keys = 4;

    pub fn get_keys(&self) -> &[::std::string::String] {
        &self.keys
    }
    pub fn clear_keys(&mut self) {
        self.keys.clear();
    }

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

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

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

    // repeated string preds = 5;

    pub fn get_preds(&self) -> &[::std::string::String] {
        &self.preds
    }
    pub fn clear_preds(&mut self) {
        self.preds.clear();
    }

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

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

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

impl ::protobuf::Message for TxnContext {
    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.start_ts = 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.commit_ts = 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_bool()?;
                    self.aborted = tmp;
                }
                4 => {
                    ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.keys)?;
                }
                5 => {
                    ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.preds)?;
                }
                _ => {
                    ::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.start_ts != 0 {
            my_size += ::protobuf::rt::value_size(
                1,
                self.start_ts,
                ::protobuf::wire_format::WireTypeVarint,
            );
        }
        if self.commit_ts != 0 {
            my_size += ::protobuf::rt::value_size(
                2,
                self.commit_ts,
                ::protobuf::wire_format::WireTypeVarint,
            );
        }
        if self.aborted != false {
            my_size += 2;
        }
        for value in &self.keys {
            my_size += ::protobuf::rt::string_size(4, &value);
        }
        for value in &self.preds {
            my_size += ::protobuf::rt::string_size(5, &value);
        }
        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.start_ts != 0 {
            os.write_uint64(1, self.start_ts)?;
        }
        if self.commit_ts != 0 {
            os.write_uint64(2, self.commit_ts)?;
        }
        if self.aborted != false {
            os.write_bool(3, self.aborted)?;
        }
        for v in &self.keys {
            os.write_string(4, &v)?;
        }
        for v in &self.preds {
            os.write_string(5, &v)?;
        }
        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() -> TxnContext {
        TxnContext::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,
            >(
                "start_ts",
                |m: &TxnContext| &m.start_ts,
                |m: &mut TxnContext| &mut m.start_ts,
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<
                _,
                ::protobuf::types::ProtobufTypeUint64,
            >(
                "commit_ts",
                |m: &TxnContext| &m.commit_ts,
                |m: &mut TxnContext| &mut m.commit_ts,
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<
                _,
                ::protobuf::types::ProtobufTypeBool,
            >(
                "aborted",
                |m: &TxnContext| &m.aborted,
                |m: &mut TxnContext| &mut m.aborted,
            ));
            fields.push(
                ::protobuf::reflect::accessor::make_repeated_field_accessor::<
                    _,
                    ::protobuf::types::ProtobufTypeString,
                >(
                    "keys",
                    |m: &TxnContext| &m.keys,
                    |m: &mut TxnContext| &mut m.keys,
                ),
            );
            fields.push(
                ::protobuf::reflect::accessor::make_repeated_field_accessor::<
                    _,
                    ::protobuf::types::ProtobufTypeString,
                >(
                    "preds",
                    |m: &TxnContext| &m.preds,
                    |m: &mut TxnContext| &mut m.preds,
                ),
            );
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<TxnContext>(
                "TxnContext",
                fields,
                file_descriptor_proto(),
            )
        })
    }

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

impl ::protobuf::Clear for TxnContext {
    fn clear(&mut self) {
        self.start_ts = 0;
        self.commit_ts = 0;
        self.aborted = false;
        self.keys.clear();
        self.preds.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq, Clone, Default)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct Check {
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

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

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

impl ::protobuf::Message for Check {
    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 {
                _ => {
                    ::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;
        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<()> {
        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() -> Check {
        Check::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> =
            ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let fields = ::std::vec::Vec::new();
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Check>(
                "Check",
                fields,
                file_descriptor_proto(),
            )
        })
    }

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

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

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

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

#[derive(PartialEq, Clone, Default)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct Version {
    // message fields
    pub tag: ::std::string::String,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string tag = 1;

    pub fn get_tag(&self) -> &str {
        &self.tag
    }
    pub fn clear_tag(&mut self) {
        self.tag.clear();
    }

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

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

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

impl ::protobuf::Message for Version {
    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.tag)?;
                }
                _ => {
                    ::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.tag.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.tag);
        }
        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.tag.is_empty() {
            os.write_string(1, &self.tag)?;
        }
        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() -> Version {
        Version::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,
            >(
                "tag", |m: &Version| &m.tag, |m: &mut Version| &mut m.tag
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Version>(
                "Version",
                fields,
                file_descriptor_proto(),
            )
        })
    }

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

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

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

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

#[derive(PartialEq, Clone, Default)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct Latency {
    // message fields
    pub parsing_ns: u64,
    pub processing_ns: u64,
    pub encoding_ns: u64,
    pub assign_timestamp_ns: u64,
    pub total_ns: u64,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // uint64 parsing_ns = 1;

    pub fn get_parsing_ns(&self) -> u64 {
        self.parsing_ns
    }
    pub fn clear_parsing_ns(&mut self) {
        self.parsing_ns = 0;
    }

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

    // uint64 processing_ns = 2;

    pub fn get_processing_ns(&self) -> u64 {
        self.processing_ns
    }
    pub fn clear_processing_ns(&mut self) {
        self.processing_ns = 0;
    }

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

    // uint64 encoding_ns = 3;

    pub fn get_encoding_ns(&self) -> u64 {
        self.encoding_ns
    }
    pub fn clear_encoding_ns(&mut self) {
        self.encoding_ns = 0;
    }

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

    // uint64 assign_timestamp_ns = 4;

    pub fn get_assign_timestamp_ns(&self) -> u64 {
        self.assign_timestamp_ns
    }
    pub fn clear_assign_timestamp_ns(&mut self) {
        self.assign_timestamp_ns = 0;
    }

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

    // uint64 total_ns = 5;

    pub fn get_total_ns(&self) -> u64 {
        self.total_ns
    }
    pub fn clear_total_ns(&mut self) {
        self.total_ns = 0;
    }

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

impl ::protobuf::Message for Latency {
    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.parsing_ns = 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.processing_ns = 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.encoding_ns = 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_uint64()?;
                    self.assign_timestamp_ns = 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_uint64()?;
                    self.total_ns = 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.parsing_ns != 0 {
            my_size += ::protobuf::rt::value_size(
                1,
                self.parsing_ns,
                ::protobuf::wire_format::WireTypeVarint,
            );
        }
        if self.processing_ns != 0 {
            my_size += ::protobuf::rt::value_size(
                2,
                self.processing_ns,
                ::protobuf::wire_format::WireTypeVarint,
            );
        }
        if self.encoding_ns != 0 {
            my_size += ::protobuf::rt::value_size(
                3,
                self.encoding_ns,
                ::protobuf::wire_format::WireTypeVarint,
            );
        }
        if self.assign_timestamp_ns != 0 {
            my_size += ::protobuf::rt::value_size(
                4,
                self.assign_timestamp_ns,
                ::protobuf::wire_format::WireTypeVarint,
            );
        }
        if self.total_ns != 0 {
            my_size += ::protobuf::rt::value_size(
                5,
                self.total_ns,
                ::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.parsing_ns != 0 {
            os.write_uint64(1, self.parsing_ns)?;
        }
        if self.processing_ns != 0 {
            os.write_uint64(2, self.processing_ns)?;
        }
        if self.encoding_ns != 0 {
            os.write_uint64(3, self.encoding_ns)?;
        }
        if self.assign_timestamp_ns != 0 {
            os.write_uint64(4, self.assign_timestamp_ns)?;
        }
        if self.total_ns != 0 {
            os.write_uint64(5, self.total_ns)?;
        }
        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() -> Latency {
        Latency::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,
            >(
                "parsing_ns",
                |m: &Latency| &m.parsing_ns,
                |m: &mut Latency| &mut m.parsing_ns,
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<
                _,
                ::protobuf::types::ProtobufTypeUint64,
            >(
                "processing_ns",
                |m: &Latency| &m.processing_ns,
                |m: &mut Latency| &mut m.processing_ns,
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<
                _,
                ::protobuf::types::ProtobufTypeUint64,
            >(
                "encoding_ns",
                |m: &Latency| &m.encoding_ns,
                |m: &mut Latency| &mut m.encoding_ns,
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<
                _,
                ::protobuf::types::ProtobufTypeUint64,
            >(
                "assign_timestamp_ns",
                |m: &Latency| &m.assign_timestamp_ns,
                |m: &mut Latency| &mut m.assign_timestamp_ns,
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<
                _,
                ::protobuf::types::ProtobufTypeUint64,
            >(
                "total_ns",
                |m: &Latency| &m.total_ns,
                |m: &mut Latency| &mut m.total_ns,
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Latency>(
                "Latency",
                fields,
                file_descriptor_proto(),
            )
        })
    }

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

impl ::protobuf::Clear for Latency {
    fn clear(&mut self) {
        self.parsing_ns = 0;
        self.processing_ns = 0;
        self.encoding_ns = 0;
        self.assign_timestamp_ns = 0;
        self.total_ns = 0;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq, Clone, Default)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct Metrics {
    // message fields
    pub num_uids: ::std::collections::HashMap<::std::string::String, u64>,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // repeated .api.Metrics.NumUidsEntry num_uids = 1;

    pub fn get_num_uids(&self) -> &::std::collections::HashMap<::std::string::String, u64> {
        &self.num_uids
    }
    pub fn clear_num_uids(&mut self) {
        self.num_uids.clear();
    }

    // Param is passed by value, moved
    pub fn set_num_uids(&mut self, v: ::std::collections::HashMap<::std::string::String, u64>) {
        self.num_uids = v;
    }

    // Mutable pointer to the field.
    pub fn mut_num_uids(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, u64> {
        &mut self.num_uids
    }

    // Take field
    pub fn take_num_uids(&mut self) -> ::std::collections::HashMap<::std::string::String, u64> {
        ::std::mem::replace(&mut self.num_uids, ::std::collections::HashMap::new())
    }
}

impl ::protobuf::Message for Metrics {
    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_map_into::<
                        ::protobuf::types::ProtobufTypeString,
                        ::protobuf::types::ProtobufTypeUint64,
                    >(wire_type, is, &mut self.num_uids)?;
                }
                _ => {
                    ::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;
        my_size += ::protobuf::rt::compute_map_size::<
            ::protobuf::types::ProtobufTypeString,
            ::protobuf::types::ProtobufTypeUint64,
        >(1, &self.num_uids);
        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<()> {
        ::protobuf::rt::write_map_with_cached_sizes::<
            ::protobuf::types::ProtobufTypeString,
            ::protobuf::types::ProtobufTypeUint64,
        >(1, &self.num_uids, os)?;
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

    fn new() -> Metrics {
        Metrics::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_map_accessor::<
                _,
                ::protobuf::types::ProtobufTypeString,
                ::protobuf::types::ProtobufTypeUint64,
            >(
                "num_uids",
                |m: &Metrics| &m.num_uids,
                |m: &mut Metrics| &mut m.num_uids,
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Metrics>(
                "Metrics",
                fields,
                file_descriptor_proto(),
            )
        })
    }

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

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

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

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

#[derive(PartialEq, Clone, Default)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct NQuad {
    // message fields
    pub subject: ::std::string::String,
    pub predicate: ::std::string::String,
    pub object_id: ::std::string::String,
    pub object_value: ::protobuf::SingularPtrField<Value>,
    pub label: ::std::string::String,
    pub lang: ::std::string::String,
    pub facets: ::protobuf::RepeatedField<Facet>,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string subject = 1;

    pub fn get_subject(&self) -> &str {
        &self.subject
    }
    pub fn clear_subject(&mut self) {
        self.subject.clear();
    }

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

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

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

    // string predicate = 2;

    pub fn get_predicate(&self) -> &str {
        &self.predicate
    }
    pub fn clear_predicate(&mut self) {
        self.predicate.clear();
    }

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

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

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

    // string object_id = 3;

    pub fn get_object_id(&self) -> &str {
        &self.object_id
    }
    pub fn clear_object_id(&mut self) {
        self.object_id.clear();
    }

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

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

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

    // .api.Value object_value = 4;

    pub fn get_object_value(&self) -> &Value {
        self.object_value
            .as_ref()
            .unwrap_or_else(|| <Value as ::protobuf::Message>::default_instance())
    }
    pub fn clear_object_value(&mut self) {
        self.object_value.clear();
    }

    pub fn has_object_value(&self) -> bool {
        self.object_value.is_some()
    }

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

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

    // Take field
    pub fn take_object_value(&mut self) -> Value {
        self.object_value.take().unwrap_or_else(|| Value::new())
    }

    // string label = 5;

    pub fn get_label(&self) -> &str {
        &self.label
    }
    pub fn clear_label(&mut self) {
        self.label.clear();
    }

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

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

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

    // string lang = 6;

    pub fn get_lang(&self) -> &str {
        &self.lang
    }
    pub fn clear_lang(&mut self) {
        self.lang.clear();
    }

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

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

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

    // repeated .api.Facet facets = 7;

    pub fn get_facets(&self) -> &[Facet] {
        &self.facets
    }
    pub fn clear_facets(&mut self) {
        self.facets.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_facets(&mut self) -> &mut ::protobuf::RepeatedField<Facet> {
        &mut self.facets
    }

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

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

    fn merge_from(
        &mut self,
        is: &mut ::protobuf::CodedInputStream<'_>,
    ) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_string_into(
                        wire_type,
                        is,
                        &mut self.subject,
                    )?;
                }
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(
                        wire_type,
                        is,
                        &mut self.predicate,
                    )?;
                }
                3 => {
                    ::protobuf::rt::read_singular_proto3_string_into(
                        wire_type,
                        is,
                        &mut self.object_id,
                    )?;
                }
                4 => {
                    ::protobuf::rt::read_singular_message_into(
                        wire_type,
                        is,
                        &mut self.object_value,
                    )?;
                }
                5 => {
                    ::protobuf::rt::read_singular_proto3_string_into(
                        wire_type,
                        is,
                        &mut self.label,
                    )?;
                }
                6 => {
                    ::protobuf::rt::read_singular_proto3_string_into(
                        wire_type,
                        is,
                        &mut self.lang,
                    )?;
                }
                7 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.facets)?;
                }
                _ => {
                    ::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.subject.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.subject);
        }
        if !self.predicate.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.predicate);
        }
        if !self.object_id.is_empty() {
            my_size += ::protobuf::rt::string_size(3, &self.object_id);
        }
        if let Some(ref v) = self.object_value.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if !self.label.is_empty() {
            my_size += ::protobuf::rt::string_size(5, &self.label);
        }
        if !self.lang.is_empty() {
            my_size += ::protobuf::rt::string_size(6, &self.lang);
        }
        for value in &self.facets {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(
        &self,
        os: &mut ::protobuf::CodedOutputStream<'_>,
    ) -> ::protobuf::ProtobufResult<()> {
        if !self.subject.is_empty() {
            os.write_string(1, &self.subject)?;
        }
        if !self.predicate.is_empty() {
            os.write_string(2, &self.predicate)?;
        }
        if !self.object_id.is_empty() {
            os.write_string(3, &self.object_id)?;
        }
        if let Some(ref v) = self.object_value.as_ref() {
            os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if !self.label.is_empty() {
            os.write_string(5, &self.label)?;
        }
        if !self.lang.is_empty() {
            os.write_string(6, &self.lang)?;
        }
        for v in &self.facets {
            os.write_tag(7, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

    fn new() -> NQuad {
        NQuad::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,
            >(
                "subject",
                |m: &NQuad| &m.subject,
                |m: &mut NQuad| &mut m.subject,
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<
                _,
                ::protobuf::types::ProtobufTypeString,
            >(
                "predicate",
                |m: &NQuad| &m.predicate,
                |m: &mut NQuad| &mut m.predicate,
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<
                _,
                ::protobuf::types::ProtobufTypeString,
            >(
                "object_id",
                |m: &NQuad| &m.object_id,
                |m: &mut NQuad| &mut m.object_id,
            ));
            fields.push(
                ::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<
                    _,
                    ::protobuf::types::ProtobufTypeMessage<Value>,
                >(
                    "object_value",
                    |m: &NQuad| &m.object_value,
                    |m: &mut NQuad| &mut m.object_value,
                ),
            );
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<
                _,
                ::protobuf::types::ProtobufTypeString,
            >(
                "label",
                |m: &NQuad| &m.label,
                |m: &mut NQuad| &mut m.label,
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<
                _,
                ::protobuf::types::ProtobufTypeString,
            >(
                "lang", |m: &NQuad| &m.lang, |m: &mut NQuad| &mut m.lang
            ));
            fields.push(
                ::protobuf::reflect::accessor::make_repeated_field_accessor::<
                    _,
                    ::protobuf::types::ProtobufTypeMessage<Facet>,
                >(
                    "facets",
                    |m: &NQuad| &m.facets,
                    |m: &mut NQuad| &mut m.facets,
                ),
            );
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<NQuad>(
                "NQuad",
                fields,
                file_descriptor_proto(),
            )
        })
    }

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

impl ::protobuf::Clear for NQuad {
    fn clear(&mut self) {
        self.subject.clear();
        self.predicate.clear();
        self.object_id.clear();
        self.object_value.clear();
        self.label.clear();
        self.lang.clear();
        self.facets.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq, Clone, Default)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct Value {
    // message oneof groups
    pub val: ::std::option::Option<Value_oneof_val>,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

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

#[derive(Clone, PartialEq, Debug)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub enum Value_oneof_val {
    default_val(::std::string::String),
    bytes_val(::std::vec::Vec<u8>),
    int_val(i64),
    bool_val(bool),
    str_val(::std::string::String),
    double_val(f64),
    geo_val(::std::vec::Vec<u8>),
    date_val(::std::vec::Vec<u8>),
    datetime_val(::std::vec::Vec<u8>),
    password_val(::std::string::String),
    uid_val(u64),
}

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

    // string default_val = 1;

    pub fn get_default_val(&self) -> &str {
        match self.val {
            ::std::option::Option::Some(Value_oneof_val::default_val(ref v)) => v,
            _ => "",
        }
    }
    pub fn clear_default_val(&mut self) {
        self.val = ::std::option::Option::None;
    }

    pub fn has_default_val(&self) -> bool {
        match self.val {
            ::std::option::Option::Some(Value_oneof_val::default_val(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_default_val(&mut self, v: ::std::string::String) {
        self.val = ::std::option::Option::Some(Value_oneof_val::default_val(v))
    }

    // Mutable pointer to the field.
    pub fn mut_default_val(&mut self) -> &mut ::std::string::String {
        if let ::std::option::Option::Some(Value_oneof_val::default_val(_)) = self.val {
        } else {
            self.val = ::std::option::Option::Some(Value_oneof_val::default_val(
                ::std::string::String::new(),
            ));
        }
        match self.val {
            ::std::option::Option::Some(Value_oneof_val::default_val(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_default_val(&mut self) -> ::std::string::String {
        if self.has_default_val() {
            match self.val.take() {
                ::std::option::Option::Some(Value_oneof_val::default_val(v)) => v,
                _ => panic!(),
            }
        } else {
            ::std::string::String::new()
        }
    }

    // bytes bytes_val = 2;

    pub fn get_bytes_val(&self) -> &[u8] {
        match self.val {
            ::std::option::Option::Some(Value_oneof_val::bytes_val(ref v)) => v,
            _ => &[],
        }
    }
    pub fn clear_bytes_val(&mut self) {
        self.val = ::std::option::Option::None;
    }

    pub fn has_bytes_val(&self) -> bool {
        match self.val {
            ::std::option::Option::Some(Value_oneof_val::bytes_val(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_bytes_val(&mut self, v: ::std::vec::Vec<u8>) {
        self.val = ::std::option::Option::Some(Value_oneof_val::bytes_val(v))
    }

    // Mutable pointer to the field.
    pub fn mut_bytes_val(&mut self) -> &mut ::std::vec::Vec<u8> {
        if let ::std::option::Option::Some(Value_oneof_val::bytes_val(_)) = self.val {
        } else {
            self.val =
                ::std::option::Option::Some(Value_oneof_val::bytes_val(::std::vec::Vec::new()));
        }
        match self.val {
            ::std::option::Option::Some(Value_oneof_val::bytes_val(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_bytes_val(&mut self) -> ::std::vec::Vec<u8> {
        if self.has_bytes_val() {
            match self.val.take() {
                ::std::option::Option::Some(Value_oneof_val::bytes_val(v)) => v,
                _ => panic!(),
            }
        } else {
            ::std::vec::Vec::new()
        }
    }

    // int64 int_val = 3;

    pub fn get_int_val(&self) -> i64 {
        match self.val {
            ::std::option::Option::Some(Value_oneof_val::int_val(v)) => v,
            _ => 0,
        }
    }
    pub fn clear_int_val(&mut self) {
        self.val = ::std::option::Option::None;
    }

    pub fn has_int_val(&self) -> bool {
        match self.val {
            ::std::option::Option::Some(Value_oneof_val::int_val(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_int_val(&mut self, v: i64) {
        self.val = ::std::option::Option::Some(Value_oneof_val::int_val(v))
    }

    // bool bool_val = 4;

    pub fn get_bool_val(&self) -> bool {
        match self.val {
            ::std::option::Option::Some(Value_oneof_val::bool_val(v)) => v,
            _ => false,
        }
    }
    pub fn clear_bool_val(&mut self) {
        self.val = ::std::option::Option::None;
    }

    pub fn has_bool_val(&self) -> bool {
        match self.val {
            ::std::option::Option::Some(Value_oneof_val::bool_val(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_bool_val(&mut self, v: bool) {
        self.val = ::std::option::Option::Some(Value_oneof_val::bool_val(v))
    }

    // string str_val = 5;

    pub fn get_str_val(&self) -> &str {
        match self.val {
            ::std::option::Option::Some(Value_oneof_val::str_val(ref v)) => v,
            _ => "",
        }
    }
    pub fn clear_str_val(&mut self) {
        self.val = ::std::option::Option::None;
    }

    pub fn has_str_val(&self) -> bool {
        match self.val {
            ::std::option::Option::Some(Value_oneof_val::str_val(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_str_val(&mut self, v: ::std::string::String) {
        self.val = ::std::option::Option::Some(Value_oneof_val::str_val(v))
    }

    // Mutable pointer to the field.
    pub fn mut_str_val(&mut self) -> &mut ::std::string::String {
        if let ::std::option::Option::Some(Value_oneof_val::str_val(_)) = self.val {
        } else {
            self.val =
                ::std::option::Option::Some(Value_oneof_val::str_val(::std::string::String::new()));
        }
        match self.val {
            ::std::option::Option::Some(Value_oneof_val::str_val(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_str_val(&mut self) -> ::std::string::String {
        if self.has_str_val() {
            match self.val.take() {
                ::std::option::Option::Some(Value_oneof_val::str_val(v)) => v,
                _ => panic!(),
            }
        } else {
            ::std::string::String::new()
        }
    }

    // double double_val = 6;

    pub fn get_double_val(&self) -> f64 {
        match self.val {
            ::std::option::Option::Some(Value_oneof_val::double_val(v)) => v,
            _ => 0.,
        }
    }
    pub fn clear_double_val(&mut self) {
        self.val = ::std::option::Option::None;
    }

    pub fn has_double_val(&self) -> bool {
        match self.val {
            ::std::option::Option::Some(Value_oneof_val::double_val(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_double_val(&mut self, v: f64) {
        self.val = ::std::option::Option::Some(Value_oneof_val::double_val(v))
    }

    // bytes geo_val = 7;

    pub fn get_geo_val(&self) -> &[u8] {
        match self.val {
            ::std::option::Option::Some(Value_oneof_val::geo_val(ref v)) => v,
            _ => &[],
        }
    }
    pub fn clear_geo_val(&mut self) {
        self.val = ::std::option::Option::None;
    }

    pub fn has_geo_val(&self) -> bool {
        match self.val {
            ::std::option::Option::Some(Value_oneof_val::geo_val(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_geo_val(&mut self, v: ::std::vec::Vec<u8>) {
        self.val = ::std::option::Option::Some(Value_oneof_val::geo_val(v))
    }

    // Mutable pointer to the field.
    pub fn mut_geo_val(&mut self) -> &mut ::std::vec::Vec<u8> {
        if let ::std::option::Option::Some(Value_oneof_val::geo_val(_)) = self.val {
        } else {
            self.val =
                ::std::option::Option::Some(Value_oneof_val::geo_val(::std::vec::Vec::new()));
        }
        match self.val {
            ::std::option::Option::Some(Value_oneof_val::geo_val(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_geo_val(&mut self) -> ::std::vec::Vec<u8> {
        if self.has_geo_val() {
            match self.val.take() {
                ::std::option::Option::Some(Value_oneof_val::geo_val(v)) => v,
                _ => panic!(),
            }
        } else {
            ::std::vec::Vec::new()
        }
    }

    // bytes date_val = 8;

    pub fn get_date_val(&self) -> &[u8] {
        match self.val {
            ::std::option::Option::Some(Value_oneof_val::date_val(ref v)) => v,
            _ => &[],
        }
    }
    pub fn clear_date_val(&mut self) {
        self.val = ::std::option::Option::None;
    }

    pub fn has_date_val(&self) -> bool {
        match self.val {
            ::std::option::Option::Some(Value_oneof_val::date_val(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_date_val(&mut self, v: ::std::vec::Vec<u8>) {
        self.val = ::std::option::Option::Some(Value_oneof_val::date_val(v))
    }

    // Mutable pointer to the field.
    pub fn mut_date_val(&mut self) -> &mut ::std::vec::Vec<u8> {
        if let ::std::option::Option::Some(Value_oneof_val::date_val(_)) = self.val {
        } else {
            self.val =
                ::std::option::Option::Some(Value_oneof_val::date_val(::std::vec::Vec::new()));
        }
        match self.val {
            ::std::option::Option::Some(Value_oneof_val::date_val(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_date_val(&mut self) -> ::std::vec::Vec<u8> {
        if self.has_date_val() {
            match self.val.take() {
                ::std::option::Option::Some(Value_oneof_val::date_val(v)) => v,
                _ => panic!(),
            }
        } else {
            ::std::vec::Vec::new()
        }
    }

    // bytes datetime_val = 9;

    pub fn get_datetime_val(&self) -> &[u8] {
        match self.val {
            ::std::option::Option::Some(Value_oneof_val::datetime_val(ref v)) => v,
            _ => &[],
        }
    }
    pub fn clear_datetime_val(&mut self) {
        self.val = ::std::option::Option::None;
    }

    pub fn has_datetime_val(&self) -> bool {
        match self.val {
            ::std::option::Option::Some(Value_oneof_val::datetime_val(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_datetime_val(&mut self, v: ::std::vec::Vec<u8>) {
        self.val = ::std::option::Option::Some(Value_oneof_val::datetime_val(v))
    }

    // Mutable pointer to the field.
    pub fn mut_datetime_val(&mut self) -> &mut ::std::vec::Vec<u8> {
        if let ::std::option::Option::Some(Value_oneof_val::datetime_val(_)) = self.val {
        } else {
            self.val =
                ::std::option::Option::Some(Value_oneof_val::datetime_val(::std::vec::Vec::new()));
        }
        match self.val {
            ::std::option::Option::Some(Value_oneof_val::datetime_val(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_datetime_val(&mut self) -> ::std::vec::Vec<u8> {
        if self.has_datetime_val() {
            match self.val.take() {
                ::std::option::Option::Some(Value_oneof_val::datetime_val(v)) => v,
                _ => panic!(),
            }
        } else {
            ::std::vec::Vec::new()
        }
    }

    // string password_val = 10;

    pub fn get_password_val(&self) -> &str {
        match self.val {
            ::std::option::Option::Some(Value_oneof_val::password_val(ref v)) => v,
            _ => "",
        }
    }
    pub fn clear_password_val(&mut self) {
        self.val = ::std::option::Option::None;
    }

    pub fn has_password_val(&self) -> bool {
        match self.val {
            ::std::option::Option::Some(Value_oneof_val::password_val(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_password_val(&mut self, v: ::std::string::String) {
        self.val = ::std::option::Option::Some(Value_oneof_val::password_val(v))
    }

    // Mutable pointer to the field.
    pub fn mut_password_val(&mut self) -> &mut ::std::string::String {
        if let ::std::option::Option::Some(Value_oneof_val::password_val(_)) = self.val {
        } else {
            self.val = ::std::option::Option::Some(Value_oneof_val::password_val(
                ::std::string::String::new(),
            ));
        }
        match self.val {
            ::std::option::Option::Some(Value_oneof_val::password_val(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_password_val(&mut self) -> ::std::string::String {
        if self.has_password_val() {
            match self.val.take() {
                ::std::option::Option::Some(Value_oneof_val::password_val(v)) => v,
                _ => panic!(),
            }
        } else {
            ::std::string::String::new()
        }
    }

    // uint64 uid_val = 11;

    pub fn get_uid_val(&self) -> u64 {
        match self.val {
            ::std::option::Option::Some(Value_oneof_val::uid_val(v)) => v,
            _ => 0,
        }
    }
    pub fn clear_uid_val(&mut self) {
        self.val = ::std::option::Option::None;
    }

    pub fn has_uid_val(&self) -> bool {
        match self.val {
            ::std::option::Option::Some(Value_oneof_val::uid_val(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_uid_val(&mut self, v: u64) {
        self.val = ::std::option::Option::Some(Value_oneof_val::uid_val(v))
    }
}

impl ::protobuf::Message for Value {
    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::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(
                            wire_type,
                        ));
                    }
                    self.val = ::std::option::Option::Some(Value_oneof_val::default_val(
                        is.read_string()?,
                    ));
                }
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(
                            wire_type,
                        ));
                    }
                    self.val =
                        ::std::option::Option::Some(Value_oneof_val::bytes_val(is.read_bytes()?));
                }
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(
                            wire_type,
                        ));
                    }
                    self.val =
                        ::std::option::Option::Some(Value_oneof_val::int_val(is.read_int64()?));
                }
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(
                            wire_type,
                        ));
                    }
                    self.val =
                        ::std::option::Option::Some(Value_oneof_val::bool_val(is.read_bool()?));
                }
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(
                            wire_type,
                        ));
                    }
                    self.val =
                        ::std::option::Option::Some(Value_oneof_val::str_val(is.read_string()?));
                }
                6 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(
                            wire_type,
                        ));
                    }
                    self.val =
                        ::std::option::Option::Some(Value_oneof_val::double_val(is.read_double()?));
                }
                7 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(
                            wire_type,
                        ));
                    }
                    self.val =
                        ::std::option::Option::Some(Value_oneof_val::geo_val(is.read_bytes()?));
                }
                8 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(
                            wire_type,
                        ));
                    }
                    self.val =
                        ::std::option::Option::Some(Value_oneof_val::date_val(is.read_bytes()?));
                }
                9 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(
                            wire_type,
                        ));
                    }
                    self.val = ::std::option::Option::Some(Value_oneof_val::datetime_val(
                        is.read_bytes()?,
                    ));
                }
                10 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(
                            wire_type,
                        ));
                    }
                    self.val = ::std::option::Option::Some(Value_oneof_val::password_val(
                        is.read_string()?,
                    ));
                }
                11 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(
                            wire_type,
                        ));
                    }
                    self.val =
                        ::std::option::Option::Some(Value_oneof_val::uid_val(is.read_uint64()?));
                }
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(
                        field_number,
                        wire_type,
                        is,
                        self.mut_unknown_fields(),
                    )?;
                }
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let ::std::option::Option::Some(ref v) = self.val {
            match v {
                &Value_oneof_val::default_val(ref v) => {
                    my_size += ::protobuf::rt::string_size(1, &v);
                }
                &Value_oneof_val::bytes_val(ref v) => {
                    my_size += ::protobuf::rt::bytes_size(2, &v);
                }
                &Value_oneof_val::int_val(v) => {
                    my_size +=
                        ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
                }
                &Value_oneof_val::bool_val(v) => {
                    my_size += 2;
                }
                &Value_oneof_val::str_val(ref v) => {
                    my_size += ::protobuf::rt::string_size(5, &v);
                }
                &Value_oneof_val::double_val(v) => {
                    my_size += 9;
                }
                &Value_oneof_val::geo_val(ref v) => {
                    my_size += ::protobuf::rt::bytes_size(7, &v);
                }
                &Value_oneof_val::date_val(ref v) => {
                    my_size += ::protobuf::rt::bytes_size(8, &v);
                }
                &Value_oneof_val::datetime_val(ref v) => {
                    my_size += ::protobuf::rt::bytes_size(9, &v);
                }
                &Value_oneof_val::password_val(ref v) => {
                    my_size += ::protobuf::rt::string_size(10, &v);
                }
                &Value_oneof_val::uid_val(v) => {
                    my_size +=
                        ::protobuf::rt::value_size(11, v, ::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 let ::std::option::Option::Some(ref v) = self.val {
            match v {
                &Value_oneof_val::default_val(ref v) => {
                    os.write_string(1, v)?;
                }
                &Value_oneof_val::bytes_val(ref v) => {
                    os.write_bytes(2, v)?;
                }
                &Value_oneof_val::int_val(v) => {
                    os.write_int64(3, v)?;
                }
                &Value_oneof_val::bool_val(v) => {
                    os.write_bool(4, v)?;
                }
                &Value_oneof_val::str_val(ref v) => {
                    os.write_string(5, v)?;
                }
                &Value_oneof_val::double_val(v) => {
                    os.write_double(6, v)?;
                }
                &Value_oneof_val::geo_val(ref v) => {
                    os.write_bytes(7, v)?;
                }
                &Value_oneof_val::date_val(ref v) => {
                    os.write_bytes(8, v)?;
                }
                &Value_oneof_val::datetime_val(ref v) => {
                    os.write_bytes(9, v)?;
                }
                &Value_oneof_val::password_val(ref v) => {
                    os.write_string(10, v)?;
                }
                &Value_oneof_val::uid_val(v) => {
                    os.write_uint64(11, v)?;
                }
            };
        }
        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() -> Value {
        Value::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_singular_string_accessor::<_>(
                    "default_val",
                    Value::has_default_val,
                    Value::get_default_val,
                ),
            );
            fields.push(
                ::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>(
                    "bytes_val",
                    Value::has_bytes_val,
                    Value::get_bytes_val,
                ),
            );
            fields.push(
                ::protobuf::reflect::accessor::make_singular_i64_accessor::<_>(
                    "int_val",
                    Value::has_int_val,
                    Value::get_int_val,
                ),
            );
            fields.push(
                ::protobuf::reflect::accessor::make_singular_bool_accessor::<_>(
                    "bool_val",
                    Value::has_bool_val,
                    Value::get_bool_val,
                ),
            );
            fields.push(
                ::protobuf::reflect::accessor::make_singular_string_accessor::<_>(
                    "str_val",
                    Value::has_str_val,
                    Value::get_str_val,
                ),
            );
            fields.push(
                ::protobuf::reflect::accessor::make_singular_f64_accessor::<_>(
                    "double_val",
                    Value::has_double_val,
                    Value::get_double_val,
                ),
            );
            fields.push(
                ::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>(
                    "geo_val",
                    Value::has_geo_val,
                    Value::get_geo_val,
                ),
            );
            fields.push(
                ::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>(
                    "date_val",
                    Value::has_date_val,
                    Value::get_date_val,
                ),
            );
            fields.push(
                ::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>(
                    "datetime_val",
                    Value::has_datetime_val,
                    Value::get_datetime_val,
                ),
            );
            fields.push(
                ::protobuf::reflect::accessor::make_singular_string_accessor::<_>(
                    "password_val",
                    Value::has_password_val,
                    Value::get_password_val,
                ),
            );
            fields.push(
                ::protobuf::reflect::accessor::make_singular_u64_accessor::<_>(
                    "uid_val",
                    Value::has_uid_val,
                    Value::get_uid_val,
                ),
            );
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Value>(
                "Value",
                fields,
                file_descriptor_proto(),
            )
        })
    }

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

impl ::protobuf::Clear for Value {
    fn clear(&mut self) {
        self.val = ::std::option::Option::None;
        self.val = ::std::option::Option::None;
        self.val = ::std::option::Option::None;
        self.val = ::std::option::Option::None;
        self.val = ::std::option::Option::None;
        self.val = ::std::option::Option::None;
        self.val = ::std::option::Option::None;
        self.val = ::std::option::Option::None;
        self.val = ::std::option::Option::None;
        self.val = ::std::option::Option::None;
        self.val = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq, Clone, Default)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct Facet {
    // message fields
    pub key: ::std::string::String,
    pub value: ::std::vec::Vec<u8>,
    pub val_type: Facet_ValType,
    pub tokens: ::protobuf::RepeatedField<::std::string::String>,
    pub alias: ::std::string::String,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string key = 1;

    pub fn get_key(&self) -> &str {
        &self.key
    }
    pub fn clear_key(&mut self) {
        self.key.clear();
    }

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

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

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

    // bytes value = 2;

    pub fn get_value(&self) -> &[u8] {
        &self.value
    }
    pub fn clear_value(&mut self) {
        self.value.clear();
    }

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

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

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

    // .api.Facet.ValType val_type = 3;

    pub fn get_val_type(&self) -> Facet_ValType {
        self.val_type
    }
    pub fn clear_val_type(&mut self) {
        self.val_type = Facet_ValType::STRING;
    }

    // Param is passed by value, moved
    pub fn set_val_type(&mut self, v: Facet_ValType) {
        self.val_type = v;
    }

    // repeated string tokens = 4;

    pub fn get_tokens(&self) -> &[::std::string::String] {
        &self.tokens
    }
    pub fn clear_tokens(&mut self) {
        self.tokens.clear();
    }

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

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

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

    // string alias = 5;

    pub fn get_alias(&self) -> &str {
        &self.alias
    }
    pub fn clear_alias(&mut self) {
        self.alias.clear();
    }

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

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

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

impl ::protobuf::Message for Facet {
    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.key)?;
                }
                2 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(
                        wire_type,
                        is,
                        &mut self.value,
                    )?;
                }
                3 => ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(
                    wire_type,
                    is,
                    &mut self.val_type,
                    3,
                    &mut self.unknown_fields,
                )?,
                4 => {
                    ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.tokens)?;
                }
                5 => {
                    ::protobuf::rt::read_singular_proto3_string_into(
                        wire_type,
                        is,
                        &mut self.alias,
                    )?;
                }
                _ => {
                    ::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.key.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.key);
        }
        if !self.value.is_empty() {
            my_size += ::protobuf::rt::bytes_size(2, &self.value);
        }
        if self.val_type != Facet_ValType::STRING {
            my_size += ::protobuf::rt::enum_size(3, self.val_type);
        }
        for value in &self.tokens {
            my_size += ::protobuf::rt::string_size(4, &value);
        }
        if !self.alias.is_empty() {
            my_size += ::protobuf::rt::string_size(5, &self.alias);
        }
        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.key.is_empty() {
            os.write_string(1, &self.key)?;
        }
        if !self.value.is_empty() {
            os.write_bytes(2, &self.value)?;
        }
        if self.val_type != Facet_ValType::STRING {
            os.write_enum(3, ::protobuf::ProtobufEnum::value(&self.val_type))?;
        }
        for v in &self.tokens {
            os.write_string(4, &v)?;
        }
        if !self.alias.is_empty() {
            os.write_string(5, &self.alias)?;
        }
        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() -> Facet {
        Facet::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,
            >(
                "key", |m: &Facet| &m.key, |m: &mut Facet| &mut m.key
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<
                _,
                ::protobuf::types::ProtobufTypeBytes,
            >(
                "value",
                |m: &Facet| &m.value,
                |m: &mut Facet| &mut m.value,
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<
                _,
                ::protobuf::types::ProtobufTypeEnum<Facet_ValType>,
            >(
                "val_type",
                |m: &Facet| &m.val_type,
                |m: &mut Facet| &mut m.val_type,
            ));
            fields.push(
                ::protobuf::reflect::accessor::make_repeated_field_accessor::<
                    _,
                    ::protobuf::types::ProtobufTypeString,
                >(
                    "tokens",
                    |m: &Facet| &m.tokens,
                    |m: &mut Facet| &mut m.tokens,
                ),
            );
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<
                _,
                ::protobuf::types::ProtobufTypeString,
            >(
                "alias",
                |m: &Facet| &m.alias,
                |m: &mut Facet| &mut m.alias,
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Facet>(
                "Facet",
                fields,
                file_descriptor_proto(),
            )
        })
    }

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

impl ::protobuf::Clear for Facet {
    fn clear(&mut self) {
        self.key.clear();
        self.value.clear();
        self.val_type = Facet_ValType::STRING;
        self.tokens.clear();
        self.alias.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(Clone, PartialEq, Eq, Debug, Hash)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub enum Facet_ValType {
    STRING = 0,
    INT = 1,
    FLOAT = 2,
    BOOL = 3,
    DATETIME = 4,
}

impl ::protobuf::ProtobufEnum for Facet_ValType {
    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<Facet_ValType> {
        match value {
            0 => ::std::option::Option::Some(Facet_ValType::STRING),
            1 => ::std::option::Option::Some(Facet_ValType::INT),
            2 => ::std::option::Option::Some(Facet_ValType::FLOAT),
            3 => ::std::option::Option::Some(Facet_ValType::BOOL),
            4 => ::std::option::Option::Some(Facet_ValType::DATETIME),
            _ => ::std::option::Option::None,
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [Facet_ValType] = &[
            Facet_ValType::STRING,
            Facet_ValType::INT,
            Facet_ValType::FLOAT,
            Facet_ValType::BOOL,
            Facet_ValType::DATETIME,
        ];
        values
    }

    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> =
            ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            ::protobuf::reflect::EnumDescriptor::new_pb_name::<Facet_ValType>(
                "Facet.ValType",
                file_descriptor_proto(),
            )
        })
    }
}

impl ::std::marker::Copy for Facet_ValType {}

impl ::std::default::Default for Facet_ValType {
    fn default() -> Self {
        Facet_ValType::STRING
    }
}

impl ::protobuf::reflect::ProtobufValue for Facet_ValType {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
    }
}

#[derive(PartialEq, Clone, Default)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct LoginRequest {
    // message fields
    pub userid: ::std::string::String,
    pub password: ::std::string::String,
    pub refresh_token: ::std::string::String,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string userid = 1;

    pub fn get_userid(&self) -> &str {
        &self.userid
    }
    pub fn clear_userid(&mut self) {
        self.userid.clear();
    }

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

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

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

    // string password = 2;

    pub fn get_password(&self) -> &str {
        &self.password
    }
    pub fn clear_password(&mut self) {
        self.password.clear();
    }

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

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

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

    // string refresh_token = 3;

    pub fn get_refresh_token(&self) -> &str {
        &self.refresh_token
    }
    pub fn clear_refresh_token(&mut self) {
        self.refresh_token.clear();
    }

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

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

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

impl ::protobuf::Message for LoginRequest {
    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.userid,
                    )?;
                }
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(
                        wire_type,
                        is,
                        &mut self.password,
                    )?;
                }
                3 => {
                    ::protobuf::rt::read_singular_proto3_string_into(
                        wire_type,
                        is,
                        &mut self.refresh_token,
                    )?;
                }
                _ => {
                    ::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.userid.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.userid);
        }
        if !self.password.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.password);
        }
        if !self.refresh_token.is_empty() {
            my_size += ::protobuf::rt::string_size(3, &self.refresh_token);
        }
        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.userid.is_empty() {
            os.write_string(1, &self.userid)?;
        }
        if !self.password.is_empty() {
            os.write_string(2, &self.password)?;
        }
        if !self.refresh_token.is_empty() {
            os.write_string(3, &self.refresh_token)?;
        }
        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() -> LoginRequest {
        LoginRequest::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,
            >(
                "userid",
                |m: &LoginRequest| &m.userid,
                |m: &mut LoginRequest| &mut m.userid,
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<
                _,
                ::protobuf::types::ProtobufTypeString,
            >(
                "password",
                |m: &LoginRequest| &m.password,
                |m: &mut LoginRequest| &mut m.password,
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<
                _,
                ::protobuf::types::ProtobufTypeString,
            >(
                "refresh_token",
                |m: &LoginRequest| &m.refresh_token,
                |m: &mut LoginRequest| &mut m.refresh_token,
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<LoginRequest>(
                "LoginRequest",
                fields,
                file_descriptor_proto(),
            )
        })
    }

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

impl ::protobuf::Clear for LoginRequest {
    fn clear(&mut self) {
        self.userid.clear();
        self.password.clear();
        self.refresh_token.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq, Clone, Default)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct Jwt {
    // message fields
    pub access_jwt: ::std::string::String,
    pub refresh_jwt: ::std::string::String,
    // special fields
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub unknown_fields: ::protobuf::UnknownFields,
    #[cfg_attr(feature = "with-serde", serde(skip))]
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string access_jwt = 1;

    pub fn get_access_jwt(&self) -> &str {
        &self.access_jwt
    }
    pub fn clear_access_jwt(&mut self) {
        self.access_jwt.clear();
    }

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

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

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

    // string refresh_jwt = 2;

    pub fn get_refresh_jwt(&self) -> &str {
        &self.refresh_jwt
    }
    pub fn clear_refresh_jwt(&mut self) {
        self.refresh_jwt.clear();
    }

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

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

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

impl ::protobuf::Message for Jwt {
    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.access_jwt,
                    )?;
                }
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(
                        wire_type,
                        is,
                        &mut self.refresh_jwt,
                    )?;
                }
                _ => {
                    ::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.access_jwt.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.access_jwt);
        }
        if !self.refresh_jwt.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.refresh_jwt);
        }
        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.access_jwt.is_empty() {
            os.write_string(1, &self.access_jwt)?;
        }
        if !self.refresh_jwt.is_empty() {
            os.write_string(2, &self.refresh_jwt)?;
        }
        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() -> Jwt {
        Jwt::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,
            >(
                "access_jwt",
                |m: &Jwt| &m.access_jwt,
                |m: &mut Jwt| &mut m.access_jwt,
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<
                _,
                ::protobuf::types::ProtobufTypeString,
            >(
                "refresh_jwt",
                |m: &Jwt| &m.refresh_jwt,
                |m: &mut Jwt| &mut m.refresh_jwt,
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Jwt>(
                "Jwt",
                fields,
                file_descriptor_proto(),
            )
        })
    }

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

impl ::protobuf::Clear for Jwt {
    fn clear(&mut self) {
        self.access_jwt.clear();
        self.refresh_jwt.clear();
        self.unknown_fields.clear();
    }
}

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

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

static file_descriptor_proto_data: &'static [u8] = b"\
    \n\tapi.proto\x12\x03api\"\xa9\x02\n\x07Request\x12\x19\n\x08start_ts\
    \x18\x01\x20\x01(\x04R\x07startTs\x12\x14\n\x05query\x18\x04\x20\x01(\tR\
    \x05query\x12*\n\x04vars\x18\x05\x20\x03(\x0b2\x16.api.Request.VarsEntry\
    R\x04vars\x12\x1b\n\tread_only\x18\x06\x20\x01(\x08R\x08readOnly\x12\x1f\
    \n\x0bbest_effort\x18\x07\x20\x01(\x08R\nbestEffort\x12+\n\tmutations\
    \x18\x0c\x20\x03(\x0b2\r.api.MutationR\tmutations\x12\x1d\n\ncommit_now\
    \x18\r\x20\x01(\x08R\tcommitNow\x1a7\n\tVarsEntry\x12\x10\n\x03key\x18\
    \x01\x20\x01(\tR\x03key\x12\x14\n\x05value\x18\x02\x20\x01(\tR\x05value:\
    \x028\x01\"\x1a\n\x04Uids\x12\x12\n\x04uids\x18\x01\x20\x03(\tR\x04uids\
    \"\xf7\x01\n\x08Response\x12\x12\n\x04json\x18\x01\x20\x01(\x0cR\x04json\
    \x12!\n\x03txn\x18\x02\x20\x01(\x0b2\x0f.api.TxnContextR\x03txn\x12&\n\
    \x07latency\x18\x03\x20\x01(\x0b2\x0c.api.LatencyR\x07latency\x12&\n\x07\
    metrics\x18\x04\x20\x01(\x0b2\x0c.api.MetricsR\x07metrics\x12+\n\x04uids\
    \x18\x0c\x20\x03(\x0b2\x17.api.Response.UidsEntryR\x04uids\x1a7\n\tUidsE\
    ntry\x12\x10\n\x03key\x18\x01\x20\x01(\tR\x03key\x12\x14\n\x05value\x18\
    \x02\x20\x01(\tR\x05value:\x028\x01\"\xf3\x01\n\x08Mutation\x12\x19\n\
    \x08set_json\x18\x01\x20\x01(\x0cR\x07setJson\x12\x1f\n\x0bdelete_json\
    \x18\x02\x20\x01(\x0cR\ndeleteJson\x12\x1d\n\nset_nquads\x18\x03\x20\x01\
    (\x0cR\tsetNquads\x12\x1d\n\ndel_nquads\x18\x04\x20\x01(\x0cR\tdelNquads\
    \x12\x1c\n\x03set\x18\x05\x20\x03(\x0b2\n.api.NQuadR\x03set\x12\x1c\n\
    \x03del\x18\x06\x20\x03(\x0b2\n.api.NQuadR\x03del\x12\x12\n\x04cond\x18\
    \t\x20\x01(\tR\x04cond\x12\x1d\n\ncommit_now\x18\x0e\x20\x01(\x08R\tcomm\
    itNow\"\x91\x02\n\tOperation\x12\x16\n\x06schema\x18\x01\x20\x01(\tR\x06\
    schema\x12\x1b\n\tdrop_attr\x18\x02\x20\x01(\tR\x08dropAttr\x12\x19\n\
    \x08drop_all\x18\x03\x20\x01(\x08R\x07dropAll\x12.\n\x07drop_op\x18\x04\
    \x20\x01(\x0e2\x15.api.Operation.DropOpR\x06dropOp\x12\x1d\n\ndrop_value\
    \x18\x05\x20\x01(\tR\tdropValue\x12*\n\x11run_in_background\x18\x06\x20\
    \x01(\x08R\x0frunInBackground\"9\n\x06DropOp\x12\x08\n\x04NONE\x10\0\x12\
    \x07\n\x03ALL\x10\x01\x12\x08\n\x04DATA\x10\x02\x12\x08\n\x04ATTR\x10\
    \x03\x12\x08\n\x04TYPE\x10\x04\"\x1d\n\x07Payload\x12\x12\n\x04Data\x18\
    \x01\x20\x01(\x0cR\x04Data\"\x88\x01\n\nTxnContext\x12\x19\n\x08start_ts\
    \x18\x01\x20\x01(\x04R\x07startTs\x12\x1b\n\tcommit_ts\x18\x02\x20\x01(\
    \x04R\x08commitTs\x12\x18\n\x07aborted\x18\x03\x20\x01(\x08R\x07aborted\
    \x12\x12\n\x04keys\x18\x04\x20\x03(\tR\x04keys\x12\x14\n\x05preds\x18\
    \x05\x20\x03(\tR\x05preds\"\x07\n\x05Check\"\x1b\n\x07Version\x12\x10\n\
    \x03tag\x18\x01\x20\x01(\tR\x03tag\"\xb9\x01\n\x07Latency\x12\x1d\n\npar\
    sing_ns\x18\x01\x20\x01(\x04R\tparsingNs\x12#\n\rprocessing_ns\x18\x02\
    \x20\x01(\x04R\x0cprocessingNs\x12\x1f\n\x0bencoding_ns\x18\x03\x20\x01(\
    \x04R\nencodingNs\x12.\n\x13assign_timestamp_ns\x18\x04\x20\x01(\x04R\
    \x11assignTimestampNs\x12\x19\n\x08total_ns\x18\x05\x20\x01(\x04R\x07tot\
    alNs\"{\n\x07Metrics\x124\n\x08num_uids\x18\x01\x20\x03(\x0b2\x19.api.Me\
    trics.NumUidsEntryR\x07numUids\x1a:\n\x0cNumUidsEntry\x12\x10\n\x03key\
    \x18\x01\x20\x01(\tR\x03key\x12\x14\n\x05value\x18\x02\x20\x01(\x04R\x05\
    value:\x028\x01\"\xd9\x01\n\x05NQuad\x12\x18\n\x07subject\x18\x01\x20\
    \x01(\tR\x07subject\x12\x1c\n\tpredicate\x18\x02\x20\x01(\tR\tpredicate\
    \x12\x1b\n\tobject_id\x18\x03\x20\x01(\tR\x08objectId\x12-\n\x0cobject_v\
    alue\x18\x04\x20\x01(\x0b2\n.api.ValueR\x0bobjectValue\x12\x14\n\x05labe\
    l\x18\x05\x20\x01(\tR\x05label\x12\x12\n\x04lang\x18\x06\x20\x01(\tR\x04\
    lang\x12\"\n\x06facets\x18\x07\x20\x03(\x0b2\n.api.FacetR\x06facets\"\
    \xe1\x02\n\x05Value\x12!\n\x0bdefault_val\x18\x01\x20\x01(\tH\0R\ndefaul\
    tVal\x12\x1d\n\tbytes_val\x18\x02\x20\x01(\x0cH\0R\x08bytesVal\x12\x19\n\
    \x07int_val\x18\x03\x20\x01(\x03H\0R\x06intVal\x12\x1b\n\x08bool_val\x18\
    \x04\x20\x01(\x08H\0R\x07boolVal\x12\x19\n\x07str_val\x18\x05\x20\x01(\t\
    H\0R\x06strVal\x12\x1f\n\ndouble_val\x18\x06\x20\x01(\x01H\0R\tdoubleVal\
    \x12\x19\n\x07geo_val\x18\x07\x20\x01(\x0cH\0R\x06geoVal\x12\x1b\n\x08da\
    te_val\x18\x08\x20\x01(\x0cH\0R\x07dateVal\x12#\n\x0cdatetime_val\x18\t\
    \x20\x01(\x0cH\0R\x0bdatetimeVal\x12#\n\x0cpassword_val\x18\n\x20\x01(\t\
    H\0R\x0bpasswordVal\x12\x19\n\x07uid_val\x18\x0b\x20\x01(\x04H\0R\x06uid\
    ValB\x05\n\x03val\"\xcf\x01\n\x05Facet\x12\x10\n\x03key\x18\x01\x20\x01(\
    \tR\x03key\x12\x14\n\x05value\x18\x02\x20\x01(\x0cR\x05value\x12-\n\x08v\
    al_type\x18\x03\x20\x01(\x0e2\x12.api.Facet.ValTypeR\x07valType\x12\x16\
    \n\x06tokens\x18\x04\x20\x03(\tR\x06tokens\x12\x14\n\x05alias\x18\x05\
    \x20\x01(\tR\x05alias\"A\n\x07ValType\x12\n\n\x06STRING\x10\0\x12\x07\n\
    \x03INT\x10\x01\x12\t\n\x05FLOAT\x10\x02\x12\x08\n\x04BOOL\x10\x03\x12\
    \x0c\n\x08DATETIME\x10\x04\"g\n\x0cLoginRequest\x12\x16\n\x06userid\x18\
    \x01\x20\x01(\tR\x06userid\x12\x1a\n\x08password\x18\x02\x20\x01(\tR\x08\
    password\x12#\n\rrefresh_token\x18\x03\x20\x01(\tR\x0crefreshToken\"E\n\
    \x03Jwt\x12\x1d\n\naccess_jwt\x18\x01\x20\x01(\tR\taccessJwt\x12\x1f\n\
    \x0brefresh_jwt\x18\x02\x20\x01(\tR\nrefreshJwt2\xe7\x01\n\x06Dgraph\x12\
    +\n\x05Login\x12\x11.api.LoginRequest\x1a\r.api.Response\"\0\x12&\n\x05Q\
    uery\x12\x0c.api.Request\x1a\r.api.Response\"\0\x12'\n\x05Alter\x12\x0e.\
    api.Operation\x1a\x0c.api.Payload\"\0\x123\n\rCommitOrAbort\x12\x0f.api.\
    TxnContext\x1a\x0f.api.TxnContext\"\0\x12*\n\x0cCheckVersion\x12\n.api.C\
    heck\x1a\x0c.api.Version\"\0B\x18\n\tio.dgraphB\x0bDgraphProtob\x06proto\
    3\
";

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())
}