dgraph_rs/protos/

api.rs

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

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

#![cfg_attr(rustfmt, rustfmt_skip)]

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

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

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

#[derive(PartialEq,Clone,Default)]
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
    pub unknown_fields: ::protobuf::UnknownFields,
    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: 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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::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::<Request>(
                    "Request",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static Request {
        static mut instance: ::protobuf::lazy::Lazy<Request> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const Request,
        };
        unsafe {
            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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct Uids {
    // message fields
    pub uids: ::protobuf::RepeatedField<::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    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: 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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "uids",
                    |m: &Uids| { &m.uids },
                    |m: &mut Uids| { &mut m.uids },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<Uids>(
                    "Uids",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static Uids {
        static mut instance: ::protobuf::lazy::Lazy<Uids> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const Uids,
        };
        unsafe {
            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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
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
    pub unknown_fields: ::protobuf::UnknownFields,
    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::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::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::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: 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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::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::<Response>(
                    "Response",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static Response {
        static mut instance: ::protobuf::lazy::Lazy<Response> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const Response,
        };
        unsafe {
            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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
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
    pub unknown_fields: ::protobuf::UnknownFields,
    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: 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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::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::<Mutation>(
                    "Mutation",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static Mutation {
        static mut instance: ::protobuf::lazy::Lazy<Mutation> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const Mutation,
        };
        unsafe {
            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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
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,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    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())
    }
}

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)?;
                },
                _ => {
                    ::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);
        }
        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, self.drop_op.value())?;
        }
        if !self.drop_value.is_empty() {
            os.write_string(5, &self.drop_value)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

    fn default_instance() -> &'static Operation {
        static mut instance: ::protobuf::lazy::Lazy<Operation> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const Operation,
        };
        unsafe {
            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.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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::EnumDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                ::protobuf::reflect::EnumDescriptor::new("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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor())
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct Payload {
    // message fields
    pub Data: ::std::vec::Vec<u8>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    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: 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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                    "Data",
                    |m: &Payload| { &m.Data },
                    |m: &mut Payload| { &mut m.Data },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<Payload>(
                    "Payload",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static Payload {
        static mut instance: ::protobuf::lazy::Lazy<Payload> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const Payload,
        };
        unsafe {
            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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
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
    pub unknown_fields: ::protobuf::UnknownFields,
    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: 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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::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::<TxnContext>(
                    "TxnContext",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static TxnContext {
        static mut instance: ::protobuf::lazy::Lazy<TxnContext> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const TxnContext,
        };
        unsafe {
            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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct Check {
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    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: 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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let fields = ::std::vec::Vec::new();
                ::protobuf::reflect::MessageDescriptor::new::<Check>(
                    "Check",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static Check {
        static mut instance: ::protobuf::lazy::Lazy<Check> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const Check,
        };
        unsafe {
            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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct Version {
    // message fields
    pub tag: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    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: 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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "tag",
                    |m: &Version| { &m.tag },
                    |m: &mut Version| { &mut m.tag },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<Version>(
                    "Version",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static Version {
        static mut instance: ::protobuf::lazy::Lazy<Version> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const Version,
        };
        unsafe {
            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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
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
    pub unknown_fields: ::protobuf::UnknownFields,
    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: 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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::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::<Latency>(
                    "Latency",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static Latency {
        static mut instance: ::protobuf::lazy::Lazy<Latency> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const Latency,
        };
        unsafe {
            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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct Metrics {
    // message fields
    pub num_uids: ::std::collections::HashMap<::std::string::String, u64>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    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: 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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_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::<Metrics>(
                    "Metrics",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static Metrics {
        static mut instance: ::protobuf::lazy::Lazy<Metrics> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const Metrics,
        };
        unsafe {
            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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
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
    pub unknown_fields: ::protobuf::UnknownFields,
    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::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: 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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::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::<NQuad>(
                    "NQuad",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static NQuad {
        static mut instance: ::protobuf::lazy::Lazy<NQuad> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const NQuad,
        };
        unsafe {
            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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct Value {
    // message oneof groups
    pub val: ::std::option::Option<Value_oneof_val>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    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)]
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: 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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_singular_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::<Value>(
                    "Value",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static Value {
        static mut instance: ::protobuf::lazy::Lazy<Value> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const Value,
        };
        unsafe {
            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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
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
    pub unknown_fields: ::protobuf::UnknownFields,
    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, self.val_type.value())?;
        }
        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: 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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::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::<Facet>(
                    "Facet",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static Facet {
        static mut instance: ::protobuf::lazy::Lazy<Facet> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const Facet,
        };
        unsafe {
            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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::EnumDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                ::protobuf::reflect::EnumDescriptor::new("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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor())
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct LoginRequest {
    // message fields
    pub userid: ::std::string::String,
    pub password: ::std::string::String,
    pub refresh_token: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    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: 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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::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::<LoginRequest>(
                    "LoginRequest",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static LoginRequest {
        static mut instance: ::protobuf::lazy::Lazy<LoginRequest> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const LoginRequest,
        };
        unsafe {
            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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct Jwt {
    // message fields
    pub access_jwt: ::std::string::String,
    pub refresh_jwt: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    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: 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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::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::<Jwt>(
                    "Jwt",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static Jwt {
        static mut instance: ::protobuf::lazy::Lazy<Jwt> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const Jwt,
        };
        unsafe {
            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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::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\"\xe5\x01\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\"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\x08star\
    t_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\x07abo\
    rted\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\nparsing_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\
    \x07totalNs\"{\n\x07Metrics\x124\n\x08num_uids\x18\x01\x20\x03(\x0b2\x19\
    .api.Metrics.NumUidsEntryR\x07numUids\x1a:\n\x0cNumUidsEntry\x12\x10\n\
    \x03key\x18\x01\x20\x01(\tR\x03key\x12\x14\n\x05value\x18\x02\x20\x01(\
    \x04R\x05value:\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\tpr\
    edicate\x12\x1b\n\tobject_id\x18\x03\x20\x01(\tR\x08objectId\x12-\n\x0co\
    bject_value\x18\x04\x20\x01(\x0b2\n.api.ValueR\x0bobjectValue\x12\x14\n\
    \x05label\x18\x05\x20\x01(\tR\x05label\x12\x12\n\x04lang\x18\x06\x20\x01\
    (\tR\x04lang\x12\"\n\x06facets\x18\x07\x20\x03(\x0b2\n.api.FacetR\x06fac\
    ets\"\xe1\x02\n\x05Value\x12!\n\x0bdefault_val\x18\x01\x20\x01(\tH\0R\nd\
    efaultVal\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_v\
    al\x18\x04\x20\x01(\x08H\0R\x07boolVal\x12\x19\n\x07str_val\x18\x05\x20\
    \x01(\tH\0R\x06strVal\x12\x1f\n\ndouble_val\x18\x06\x20\x01(\x01H\0R\tdo\
    ubleVal\x12\x19\n\x07geo_val\x18\x07\x20\x01(\x0cH\0R\x06geoVal\x12\x1b\
    \n\x08date_val\x18\x08\x20\x01(\x0cH\0R\x07dateVal\x12#\n\x0cdatetime_va\
    l\x18\t\x20\x01(\x0cH\0R\x0bdatetimeVal\x12#\n\x0cpassword_val\x18\n\x20\
    \x01(\tH\0R\x0bpasswordVal\x12\x19\n\x07uid_val\x18\x0b\x20\x01(\x04H\0R\
    \x06uidValB\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\x08val_type\x18\x03\x20\x01(\x0e2\x12.api.Facet.ValTypeR\x07valT\
    ype\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\x06use\
    rid\x18\x01\x20\x01(\tR\x06userid\x12\x1a\n\x08password\x18\x02\x20\x01(\
    \tR\x08password\x12#\n\rrefresh_token\x18\x03\x20\x01(\tR\x0crefreshToke\
    n\"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\x06Dgra\
    ph\x12+\n\x05Login\x12\x11.api.LoginRequest\x1a\r.api.Response\"\0\x12&\
    \n\x05Query\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.Check\x1a\x0c.api.Version\"\0B\x18\n\tio.dgraphB\x0bDgraphPro\
    tob\x06proto3\
";

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

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

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