diff --git a/src/buf_read_iter.rs b/src/buf_read_iter.rs
index 318185d..149a2ea 100644
--- a/src/buf_read_iter.rs
+++ b/src/buf_read_iter.rs
@@ -12,10 +12,10 @@
 #[cfg(feature = "bytes")]
 use bytes::BytesMut;
 
-use error::WireError;
-use stream::READ_RAW_BYTES_MAX_ALLOC;
-use ProtobufError;
-use ProtobufResult;
+use crate::error::WireError;
+use crate::stream::READ_RAW_BYTES_MAX_ALLOC;
+use crate::ProtobufError;
+use crate::ProtobufResult;
 
 use std::mem::MaybeUninit;
 
diff --git a/src/compiler_plugin.rs b/src/compiler_plugin.rs
index 2a3b1d0..b23f905 100644
--- a/src/compiler_plugin.rs
+++ b/src/compiler_plugin.rs
@@ -1,10 +1,10 @@
 // TODO: move into separate crate
 #![doc(hidden)]
 
-use plugin::*;
-use protobuf::descriptor::FileDescriptorProto;
-use protobuf::parse_from_reader;
-use protobuf::Message;
+use crate::descriptor::FileDescriptorProto;
+use crate::parse_from_reader;
+use crate::plugin::*;
+use crate::Message;
 use std::io::stdin;
 use std::io::stdout;
 use std::str;
diff --git a/src/descriptor.rs b/src/descriptor.rs
index 4a0ec17..a03970a 100644
--- a/src/descriptor.rs
+++ b/src/descriptor.rs
@@ -1,4 +1,4 @@
-// This file is generated by rust-protobuf 2.16.0-pre. Do not edit
+// This file is generated by rust-protobuf 2.17.0-pre. Do not edit
 // @generated
 
 // https://github.com/rust-lang/rust-clippy/issues/702
@@ -23,17 +23,17 @@
 #[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
 pub struct FileDescriptorSet {
     // message fields
-    pub file: ::protobuf::RepeatedField<FileDescriptorProto>,
+    pub file: crate::RepeatedField<FileDescriptorProto>,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a FileDescriptorSet {
     fn default() -> &'a FileDescriptorSet {
-        <FileDescriptorSet as ::protobuf::Message>::default_instance()
+        <FileDescriptorSet as crate::Message>::default_instance()
     }
 }
 
@@ -53,22 +53,22 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_file(&mut self, v: ::protobuf::RepeatedField<FileDescriptorProto>) {
+    pub fn set_file(&mut self, v: crate::RepeatedField<FileDescriptorProto>) {
         self.file = v;
     }
 
     // Mutable pointer to the field.
-    pub fn mut_file(&mut self) -> &mut ::protobuf::RepeatedField<FileDescriptorProto> {
+    pub fn mut_file(&mut self) -> &mut crate::RepeatedField<FileDescriptorProto> {
         &mut self.file
     }
 
     // Take field
-    pub fn take_file(&mut self) -> ::protobuf::RepeatedField<FileDescriptorProto> {
-        ::std::mem::replace(&mut self.file, ::protobuf::RepeatedField::new())
+    pub fn take_file(&mut self) -> crate::RepeatedField<FileDescriptorProto> {
+        ::std::mem::replace(&mut self.file, crate::RepeatedField::new())
     }
 }
 
-impl ::protobuf::Message for FileDescriptorSet {
+impl crate::Message for FileDescriptorSet {
     fn is_initialized(&self) -> bool {
         for v in &self.file {
             if !v.is_initialized() {
@@ -78,15 +78,15 @@
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
         while !is.eof()? {
             let (field_number, wire_type) = is.read_tag_unpack()?;
             match field_number {
                 1 => {
-                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.file)?;
+                    crate::rt::read_repeated_message_into(wire_type, is, &mut self.file)?;
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -99,16 +99,16 @@
         let mut my_size = 0;
         for value in &self.file {
             let len = value.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
         };
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         for v in &self.file {
-            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(1, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         };
@@ -120,11 +120,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -138,7 +138,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -146,16 +146,16 @@
         FileDescriptorSet::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<FileDescriptorProto>>(
+            fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<FileDescriptorProto>>(
                 "file",
                 |m: &FileDescriptorSet| { &m.file },
                 |m: &mut FileDescriptorSet| { &mut m.file },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<FileDescriptorSet>(
+            crate::reflect::MessageDescriptor::new_pb_name::<FileDescriptorSet>(
                 "FileDescriptorSet",
                 fields,
                 file_descriptor_proto()
@@ -164,12 +164,12 @@
     }
 
     fn default_instance() -> &'static FileDescriptorSet {
-        static instance: ::protobuf::rt::LazyV2<FileDescriptorSet> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<FileDescriptorSet> = crate::rt::LazyV2::INIT;
         instance.get(FileDescriptorSet::new)
     }
 }
 
-impl ::protobuf::Clear for FileDescriptorSet {
+impl crate::Clear for FileDescriptorSet {
     fn clear(&mut self) {
         self.file.clear();
         self.unknown_fields.clear();
@@ -178,13 +178,13 @@
 
 impl ::std::fmt::Debug for FileDescriptorSet {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for FileDescriptorSet {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for FileDescriptorSet {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -192,28 +192,28 @@
 #[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
 pub struct FileDescriptorProto {
     // message fields
-    name: ::protobuf::SingularField<::std::string::String>,
-    package: ::protobuf::SingularField<::std::string::String>,
-    pub dependency: ::protobuf::RepeatedField<::std::string::String>,
+    name: crate::SingularField<::std::string::String>,
+    package: crate::SingularField<::std::string::String>,
+    pub dependency: crate::RepeatedField<::std::string::String>,
     pub public_dependency: ::std::vec::Vec<i32>,
     pub weak_dependency: ::std::vec::Vec<i32>,
-    pub message_type: ::protobuf::RepeatedField<DescriptorProto>,
-    pub enum_type: ::protobuf::RepeatedField<EnumDescriptorProto>,
-    pub service: ::protobuf::RepeatedField<ServiceDescriptorProto>,
-    pub extension: ::protobuf::RepeatedField<FieldDescriptorProto>,
-    pub options: ::protobuf::SingularPtrField<FileOptions>,
-    pub source_code_info: ::protobuf::SingularPtrField<SourceCodeInfo>,
-    syntax: ::protobuf::SingularField<::std::string::String>,
+    pub message_type: crate::RepeatedField<DescriptorProto>,
+    pub enum_type: crate::RepeatedField<EnumDescriptorProto>,
+    pub service: crate::RepeatedField<ServiceDescriptorProto>,
+    pub extension: crate::RepeatedField<FieldDescriptorProto>,
+    pub options: crate::SingularPtrField<FileOptions>,
+    pub source_code_info: crate::SingularPtrField<SourceCodeInfo>,
+    syntax: crate::SingularField<::std::string::String>,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a FileDescriptorProto {
     fn default() -> &'a FileDescriptorProto {
-        <FileDescriptorProto as ::protobuf::Message>::default_instance()
+        <FileDescriptorProto as crate::Message>::default_instance()
     }
 }
 
@@ -241,7 +241,7 @@
 
     // Param is passed by value, moved
     pub fn set_name(&mut self, v: ::std::string::String) {
-        self.name = ::protobuf::SingularField::some(v);
+        self.name = crate::SingularField::some(v);
     }
 
     // Mutable pointer to the field.
@@ -277,7 +277,7 @@
 
     // Param is passed by value, moved
     pub fn set_package(&mut self, v: ::std::string::String) {
-        self.package = ::protobuf::SingularField::some(v);
+        self.package = crate::SingularField::some(v);
     }
 
     // Mutable pointer to the field.
@@ -305,18 +305,18 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_dependency(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
+    pub fn set_dependency(&mut self, v: crate::RepeatedField<::std::string::String>) {
         self.dependency = v;
     }
 
     // Mutable pointer to the field.
-    pub fn mut_dependency(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
+    pub fn mut_dependency(&mut self) -> &mut crate::RepeatedField<::std::string::String> {
         &mut self.dependency
     }
 
     // Take field
-    pub fn take_dependency(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
-        ::std::mem::replace(&mut self.dependency, ::protobuf::RepeatedField::new())
+    pub fn take_dependency(&mut self) -> crate::RepeatedField<::std::string::String> {
+        ::std::mem::replace(&mut self.dependency, crate::RepeatedField::new())
     }
 
     // repeated int32 public_dependency = 10;
@@ -380,18 +380,18 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_message_type(&mut self, v: ::protobuf::RepeatedField<DescriptorProto>) {
+    pub fn set_message_type(&mut self, v: crate::RepeatedField<DescriptorProto>) {
         self.message_type = v;
     }
 
     // Mutable pointer to the field.
-    pub fn mut_message_type(&mut self) -> &mut ::protobuf::RepeatedField<DescriptorProto> {
+    pub fn mut_message_type(&mut self) -> &mut crate::RepeatedField<DescriptorProto> {
         &mut self.message_type
     }
 
     // Take field
-    pub fn take_message_type(&mut self) -> ::protobuf::RepeatedField<DescriptorProto> {
-        ::std::mem::replace(&mut self.message_type, ::protobuf::RepeatedField::new())
+    pub fn take_message_type(&mut self) -> crate::RepeatedField<DescriptorProto> {
+        ::std::mem::replace(&mut self.message_type, crate::RepeatedField::new())
     }
 
     // repeated .google.protobuf.EnumDescriptorProto enum_type = 5;
@@ -405,18 +405,18 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_enum_type(&mut self, v: ::protobuf::RepeatedField<EnumDescriptorProto>) {
+    pub fn set_enum_type(&mut self, v: crate::RepeatedField<EnumDescriptorProto>) {
         self.enum_type = v;
     }
 
     // Mutable pointer to the field.
-    pub fn mut_enum_type(&mut self) -> &mut ::protobuf::RepeatedField<EnumDescriptorProto> {
+    pub fn mut_enum_type(&mut self) -> &mut crate::RepeatedField<EnumDescriptorProto> {
         &mut self.enum_type
     }
 
     // Take field
-    pub fn take_enum_type(&mut self) -> ::protobuf::RepeatedField<EnumDescriptorProto> {
-        ::std::mem::replace(&mut self.enum_type, ::protobuf::RepeatedField::new())
+    pub fn take_enum_type(&mut self) -> crate::RepeatedField<EnumDescriptorProto> {
+        ::std::mem::replace(&mut self.enum_type, crate::RepeatedField::new())
     }
 
     // repeated .google.protobuf.ServiceDescriptorProto service = 6;
@@ -430,18 +430,18 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_service(&mut self, v: ::protobuf::RepeatedField<ServiceDescriptorProto>) {
+    pub fn set_service(&mut self, v: crate::RepeatedField<ServiceDescriptorProto>) {
         self.service = v;
     }
 
     // Mutable pointer to the field.
-    pub fn mut_service(&mut self) -> &mut ::protobuf::RepeatedField<ServiceDescriptorProto> {
+    pub fn mut_service(&mut self) -> &mut crate::RepeatedField<ServiceDescriptorProto> {
         &mut self.service
     }
 
     // Take field
-    pub fn take_service(&mut self) -> ::protobuf::RepeatedField<ServiceDescriptorProto> {
-        ::std::mem::replace(&mut self.service, ::protobuf::RepeatedField::new())
+    pub fn take_service(&mut self) -> crate::RepeatedField<ServiceDescriptorProto> {
+        ::std::mem::replace(&mut self.service, crate::RepeatedField::new())
     }
 
     // repeated .google.protobuf.FieldDescriptorProto extension = 7;
@@ -455,25 +455,25 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_extension(&mut self, v: ::protobuf::RepeatedField<FieldDescriptorProto>) {
+    pub fn set_extension(&mut self, v: crate::RepeatedField<FieldDescriptorProto>) {
         self.extension = v;
     }
 
     // Mutable pointer to the field.
-    pub fn mut_extension(&mut self) -> &mut ::protobuf::RepeatedField<FieldDescriptorProto> {
+    pub fn mut_extension(&mut self) -> &mut crate::RepeatedField<FieldDescriptorProto> {
         &mut self.extension
     }
 
     // Take field
-    pub fn take_extension(&mut self) -> ::protobuf::RepeatedField<FieldDescriptorProto> {
-        ::std::mem::replace(&mut self.extension, ::protobuf::RepeatedField::new())
+    pub fn take_extension(&mut self) -> crate::RepeatedField<FieldDescriptorProto> {
+        ::std::mem::replace(&mut self.extension, crate::RepeatedField::new())
     }
 
     // optional .google.protobuf.FileOptions options = 8;
 
 
     pub fn get_options(&self) -> &FileOptions {
-        self.options.as_ref().unwrap_or_else(|| <FileOptions as ::protobuf::Message>::default_instance())
+        self.options.as_ref().unwrap_or_else(|| <FileOptions as crate::Message>::default_instance())
     }
     pub fn clear_options(&mut self) {
         self.options.clear();
@@ -485,7 +485,7 @@
 
     // Param is passed by value, moved
     pub fn set_options(&mut self, v: FileOptions) {
-        self.options = ::protobuf::SingularPtrField::some(v);
+        self.options = crate::SingularPtrField::some(v);
     }
 
     // Mutable pointer to the field.
@@ -506,7 +506,7 @@
 
 
     pub fn get_source_code_info(&self) -> &SourceCodeInfo {
-        self.source_code_info.as_ref().unwrap_or_else(|| <SourceCodeInfo as ::protobuf::Message>::default_instance())
+        self.source_code_info.as_ref().unwrap_or_else(|| <SourceCodeInfo as crate::Message>::default_instance())
     }
     pub fn clear_source_code_info(&mut self) {
         self.source_code_info.clear();
@@ -518,7 +518,7 @@
 
     // Param is passed by value, moved
     pub fn set_source_code_info(&mut self, v: SourceCodeInfo) {
-        self.source_code_info = ::protobuf::SingularPtrField::some(v);
+        self.source_code_info = crate::SingularPtrField::some(v);
     }
 
     // Mutable pointer to the field.
@@ -554,7 +554,7 @@
 
     // Param is passed by value, moved
     pub fn set_syntax(&mut self, v: ::std::string::String) {
-        self.syntax = ::protobuf::SingularField::some(v);
+        self.syntax = crate::SingularField::some(v);
     }
 
     // Mutable pointer to the field.
@@ -572,7 +572,7 @@
     }
 }
 
-impl ::protobuf::Message for FileDescriptorProto {
+impl crate::Message for FileDescriptorProto {
     fn is_initialized(&self) -> bool {
         for v in &self.message_type {
             if !v.is_initialized() {
@@ -607,48 +607,48 @@
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
         while !is.eof()? {
             let (field_number, wire_type) = is.read_tag_unpack()?;
             match field_number {
                 1 => {
-                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.name)?;
+                    crate::rt::read_singular_string_into(wire_type, is, &mut self.name)?;
                 },
                 2 => {
-                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.package)?;
+                    crate::rt::read_singular_string_into(wire_type, is, &mut self.package)?;
                 },
                 3 => {
-                    ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.dependency)?;
+                    crate::rt::read_repeated_string_into(wire_type, is, &mut self.dependency)?;
                 },
                 10 => {
-                    ::protobuf::rt::read_repeated_int32_into(wire_type, is, &mut self.public_dependency)?;
+                    crate::rt::read_repeated_int32_into(wire_type, is, &mut self.public_dependency)?;
                 },
                 11 => {
-                    ::protobuf::rt::read_repeated_int32_into(wire_type, is, &mut self.weak_dependency)?;
+                    crate::rt::read_repeated_int32_into(wire_type, is, &mut self.weak_dependency)?;
                 },
                 4 => {
-                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.message_type)?;
+                    crate::rt::read_repeated_message_into(wire_type, is, &mut self.message_type)?;
                 },
                 5 => {
-                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.enum_type)?;
+                    crate::rt::read_repeated_message_into(wire_type, is, &mut self.enum_type)?;
                 },
                 6 => {
-                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.service)?;
+                    crate::rt::read_repeated_message_into(wire_type, is, &mut self.service)?;
                 },
                 7 => {
-                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.extension)?;
+                    crate::rt::read_repeated_message_into(wire_type, is, &mut self.extension)?;
                 },
                 8 => {
-                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.options)?;
+                    crate::rt::read_singular_message_into(wire_type, is, &mut self.options)?;
                 },
                 9 => {
-                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.source_code_info)?;
+                    crate::rt::read_singular_message_into(wire_type, is, &mut self.source_code_info)?;
                 },
                 12 => {
-                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.syntax)?;
+                    crate::rt::read_singular_string_into(wire_type, is, &mut self.syntax)?;
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -660,53 +660,53 @@
     fn compute_size(&self) -> u32 {
         let mut my_size = 0;
         if let Some(ref v) = self.name.as_ref() {
-            my_size += ::protobuf::rt::string_size(1, &v);
+            my_size += crate::rt::string_size(1, &v);
         }
         if let Some(ref v) = self.package.as_ref() {
-            my_size += ::protobuf::rt::string_size(2, &v);
+            my_size += crate::rt::string_size(2, &v);
         }
         for value in &self.dependency {
-            my_size += ::protobuf::rt::string_size(3, &value);
+            my_size += crate::rt::string_size(3, &value);
         };
         for value in &self.public_dependency {
-            my_size += ::protobuf::rt::value_size(10, *value, ::protobuf::wire_format::WireTypeVarint);
+            my_size += crate::rt::value_size(10, *value, crate::wire_format::WireTypeVarint);
         };
         for value in &self.weak_dependency {
-            my_size += ::protobuf::rt::value_size(11, *value, ::protobuf::wire_format::WireTypeVarint);
+            my_size += crate::rt::value_size(11, *value, crate::wire_format::WireTypeVarint);
         };
         for value in &self.message_type {
             let len = value.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
         };
         for value in &self.enum_type {
             let len = value.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
         };
         for value in &self.service {
             let len = value.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
         };
         for value in &self.extension {
             let len = value.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
         };
         if let Some(ref v) = self.options.as_ref() {
             let len = v.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
         }
         if let Some(ref v) = self.source_code_info.as_ref() {
             let len = v.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
         }
         if let Some(ref v) = self.syntax.as_ref() {
-            my_size += ::protobuf::rt::string_size(12, &v);
+            my_size += crate::rt::string_size(12, &v);
         }
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         if let Some(ref v) = self.name.as_ref() {
             os.write_string(1, &v)?;
         }
@@ -723,32 +723,32 @@
             os.write_int32(11, *v)?;
         };
         for v in &self.message_type {
-            os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(4, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         };
         for v in &self.enum_type {
-            os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(5, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         };
         for v in &self.service {
-            os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(6, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         };
         for v in &self.extension {
-            os.write_tag(7, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(7, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         };
         if let Some(ref v) = self.options.as_ref() {
-            os.write_tag(8, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(8, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         }
         if let Some(ref v) = self.source_code_info.as_ref() {
-            os.write_tag(9, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(9, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         }
@@ -763,11 +763,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -781,7 +781,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -789,71 +789,71 @@
         FileDescriptorProto::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "name",
                 |m: &FileDescriptorProto| { &m.name },
                 |m: &mut FileDescriptorProto| { &mut m.name },
             ));
-            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "package",
                 |m: &FileDescriptorProto| { &m.package },
                 |m: &mut FileDescriptorProto| { &mut m.package },
             ));
-            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "dependency",
                 |m: &FileDescriptorProto| { &m.dependency },
                 |m: &mut FileDescriptorProto| { &mut m.dependency },
             ));
-            fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
+            fields.push(crate::reflect::accessor::make_vec_accessor::<_, crate::types::ProtobufTypeInt32>(
                 "public_dependency",
                 |m: &FileDescriptorProto| { &m.public_dependency },
                 |m: &mut FileDescriptorProto| { &mut m.public_dependency },
             ));
-            fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
+            fields.push(crate::reflect::accessor::make_vec_accessor::<_, crate::types::ProtobufTypeInt32>(
                 "weak_dependency",
                 |m: &FileDescriptorProto| { &m.weak_dependency },
                 |m: &mut FileDescriptorProto| { &mut m.weak_dependency },
             ));
-            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<DescriptorProto>>(
+            fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<DescriptorProto>>(
                 "message_type",
                 |m: &FileDescriptorProto| { &m.message_type },
                 |m: &mut FileDescriptorProto| { &mut m.message_type },
             ));
-            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<EnumDescriptorProto>>(
+            fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<EnumDescriptorProto>>(
                 "enum_type",
                 |m: &FileDescriptorProto| { &m.enum_type },
                 |m: &mut FileDescriptorProto| { &mut m.enum_type },
             ));
-            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ServiceDescriptorProto>>(
+            fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<ServiceDescriptorProto>>(
                 "service",
                 |m: &FileDescriptorProto| { &m.service },
                 |m: &mut FileDescriptorProto| { &mut m.service },
             ));
-            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<FieldDescriptorProto>>(
+            fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<FieldDescriptorProto>>(
                 "extension",
                 |m: &FileDescriptorProto| { &m.extension },
                 |m: &mut FileDescriptorProto| { &mut m.extension },
             ));
-            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<FileOptions>>(
+            fields.push(crate::reflect::accessor::make_singular_ptr_field_accessor::<_, crate::types::ProtobufTypeMessage<FileOptions>>(
                 "options",
                 |m: &FileDescriptorProto| { &m.options },
                 |m: &mut FileDescriptorProto| { &mut m.options },
             ));
-            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<SourceCodeInfo>>(
+            fields.push(crate::reflect::accessor::make_singular_ptr_field_accessor::<_, crate::types::ProtobufTypeMessage<SourceCodeInfo>>(
                 "source_code_info",
                 |m: &FileDescriptorProto| { &m.source_code_info },
                 |m: &mut FileDescriptorProto| { &mut m.source_code_info },
             ));
-            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "syntax",
                 |m: &FileDescriptorProto| { &m.syntax },
                 |m: &mut FileDescriptorProto| { &mut m.syntax },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<FileDescriptorProto>(
+            crate::reflect::MessageDescriptor::new_pb_name::<FileDescriptorProto>(
                 "FileDescriptorProto",
                 fields,
                 file_descriptor_proto()
@@ -862,12 +862,12 @@
     }
 
     fn default_instance() -> &'static FileDescriptorProto {
-        static instance: ::protobuf::rt::LazyV2<FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<FileDescriptorProto> = crate::rt::LazyV2::INIT;
         instance.get(FileDescriptorProto::new)
     }
 }
 
-impl ::protobuf::Clear for FileDescriptorProto {
+impl crate::Clear for FileDescriptorProto {
     fn clear(&mut self) {
         self.name.clear();
         self.package.clear();
@@ -887,13 +887,13 @@
 
 impl ::std::fmt::Debug for FileDescriptorProto {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for FileDescriptorProto {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for FileDescriptorProto {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -901,26 +901,26 @@
 #[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
 pub struct DescriptorProto {
     // message fields
-    name: ::protobuf::SingularField<::std::string::String>,
-    pub field: ::protobuf::RepeatedField<FieldDescriptorProto>,
-    pub extension: ::protobuf::RepeatedField<FieldDescriptorProto>,
-    pub nested_type: ::protobuf::RepeatedField<DescriptorProto>,
-    pub enum_type: ::protobuf::RepeatedField<EnumDescriptorProto>,
-    pub extension_range: ::protobuf::RepeatedField<DescriptorProto_ExtensionRange>,
-    pub oneof_decl: ::protobuf::RepeatedField<OneofDescriptorProto>,
-    pub options: ::protobuf::SingularPtrField<MessageOptions>,
-    pub reserved_range: ::protobuf::RepeatedField<DescriptorProto_ReservedRange>,
-    pub reserved_name: ::protobuf::RepeatedField<::std::string::String>,
+    name: crate::SingularField<::std::string::String>,
+    pub field: crate::RepeatedField<FieldDescriptorProto>,
+    pub extension: crate::RepeatedField<FieldDescriptorProto>,
+    pub nested_type: crate::RepeatedField<DescriptorProto>,
+    pub enum_type: crate::RepeatedField<EnumDescriptorProto>,
+    pub extension_range: crate::RepeatedField<DescriptorProto_ExtensionRange>,
+    pub oneof_decl: crate::RepeatedField<OneofDescriptorProto>,
+    pub options: crate::SingularPtrField<MessageOptions>,
+    pub reserved_range: crate::RepeatedField<DescriptorProto_ReservedRange>,
+    pub reserved_name: crate::RepeatedField<::std::string::String>,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a DescriptorProto {
     fn default() -> &'a DescriptorProto {
-        <DescriptorProto as ::protobuf::Message>::default_instance()
+        <DescriptorProto as crate::Message>::default_instance()
     }
 }
 
@@ -948,7 +948,7 @@
 
     // Param is passed by value, moved
     pub fn set_name(&mut self, v: ::std::string::String) {
-        self.name = ::protobuf::SingularField::some(v);
+        self.name = crate::SingularField::some(v);
     }
 
     // Mutable pointer to the field.
@@ -976,18 +976,18 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_field(&mut self, v: ::protobuf::RepeatedField<FieldDescriptorProto>) {
+    pub fn set_field(&mut self, v: crate::RepeatedField<FieldDescriptorProto>) {
         self.field = v;
     }
 
     // Mutable pointer to the field.
-    pub fn mut_field(&mut self) -> &mut ::protobuf::RepeatedField<FieldDescriptorProto> {
+    pub fn mut_field(&mut self) -> &mut crate::RepeatedField<FieldDescriptorProto> {
         &mut self.field
     }
 
     // Take field
-    pub fn take_field(&mut self) -> ::protobuf::RepeatedField<FieldDescriptorProto> {
-        ::std::mem::replace(&mut self.field, ::protobuf::RepeatedField::new())
+    pub fn take_field(&mut self) -> crate::RepeatedField<FieldDescriptorProto> {
+        ::std::mem::replace(&mut self.field, crate::RepeatedField::new())
     }
 
     // repeated .google.protobuf.FieldDescriptorProto extension = 6;
@@ -1001,18 +1001,18 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_extension(&mut self, v: ::protobuf::RepeatedField<FieldDescriptorProto>) {
+    pub fn set_extension(&mut self, v: crate::RepeatedField<FieldDescriptorProto>) {
         self.extension = v;
     }
 
     // Mutable pointer to the field.
-    pub fn mut_extension(&mut self) -> &mut ::protobuf::RepeatedField<FieldDescriptorProto> {
+    pub fn mut_extension(&mut self) -> &mut crate::RepeatedField<FieldDescriptorProto> {
         &mut self.extension
     }
 
     // Take field
-    pub fn take_extension(&mut self) -> ::protobuf::RepeatedField<FieldDescriptorProto> {
-        ::std::mem::replace(&mut self.extension, ::protobuf::RepeatedField::new())
+    pub fn take_extension(&mut self) -> crate::RepeatedField<FieldDescriptorProto> {
+        ::std::mem::replace(&mut self.extension, crate::RepeatedField::new())
     }
 
     // repeated .google.protobuf.DescriptorProto nested_type = 3;
@@ -1026,18 +1026,18 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_nested_type(&mut self, v: ::protobuf::RepeatedField<DescriptorProto>) {
+    pub fn set_nested_type(&mut self, v: crate::RepeatedField<DescriptorProto>) {
         self.nested_type = v;
     }
 
     // Mutable pointer to the field.
-    pub fn mut_nested_type(&mut self) -> &mut ::protobuf::RepeatedField<DescriptorProto> {
+    pub fn mut_nested_type(&mut self) -> &mut crate::RepeatedField<DescriptorProto> {
         &mut self.nested_type
     }
 
     // Take field
-    pub fn take_nested_type(&mut self) -> ::protobuf::RepeatedField<DescriptorProto> {
-        ::std::mem::replace(&mut self.nested_type, ::protobuf::RepeatedField::new())
+    pub fn take_nested_type(&mut self) -> crate::RepeatedField<DescriptorProto> {
+        ::std::mem::replace(&mut self.nested_type, crate::RepeatedField::new())
     }
 
     // repeated .google.protobuf.EnumDescriptorProto enum_type = 4;
@@ -1051,18 +1051,18 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_enum_type(&mut self, v: ::protobuf::RepeatedField<EnumDescriptorProto>) {
+    pub fn set_enum_type(&mut self, v: crate::RepeatedField<EnumDescriptorProto>) {
         self.enum_type = v;
     }
 
     // Mutable pointer to the field.
-    pub fn mut_enum_type(&mut self) -> &mut ::protobuf::RepeatedField<EnumDescriptorProto> {
+    pub fn mut_enum_type(&mut self) -> &mut crate::RepeatedField<EnumDescriptorProto> {
         &mut self.enum_type
     }
 
     // Take field
-    pub fn take_enum_type(&mut self) -> ::protobuf::RepeatedField<EnumDescriptorProto> {
-        ::std::mem::replace(&mut self.enum_type, ::protobuf::RepeatedField::new())
+    pub fn take_enum_type(&mut self) -> crate::RepeatedField<EnumDescriptorProto> {
+        ::std::mem::replace(&mut self.enum_type, crate::RepeatedField::new())
     }
 
     // repeated .google.protobuf.DescriptorProto.ExtensionRange extension_range = 5;
@@ -1076,18 +1076,18 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_extension_range(&mut self, v: ::protobuf::RepeatedField<DescriptorProto_ExtensionRange>) {
+    pub fn set_extension_range(&mut self, v: crate::RepeatedField<DescriptorProto_ExtensionRange>) {
         self.extension_range = v;
     }
 
     // Mutable pointer to the field.
-    pub fn mut_extension_range(&mut self) -> &mut ::protobuf::RepeatedField<DescriptorProto_ExtensionRange> {
+    pub fn mut_extension_range(&mut self) -> &mut crate::RepeatedField<DescriptorProto_ExtensionRange> {
         &mut self.extension_range
     }
 
     // Take field
-    pub fn take_extension_range(&mut self) -> ::protobuf::RepeatedField<DescriptorProto_ExtensionRange> {
-        ::std::mem::replace(&mut self.extension_range, ::protobuf::RepeatedField::new())
+    pub fn take_extension_range(&mut self) -> crate::RepeatedField<DescriptorProto_ExtensionRange> {
+        ::std::mem::replace(&mut self.extension_range, crate::RepeatedField::new())
     }
 
     // repeated .google.protobuf.OneofDescriptorProto oneof_decl = 8;
@@ -1101,25 +1101,25 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_oneof_decl(&mut self, v: ::protobuf::RepeatedField<OneofDescriptorProto>) {
+    pub fn set_oneof_decl(&mut self, v: crate::RepeatedField<OneofDescriptorProto>) {
         self.oneof_decl = v;
     }
 
     // Mutable pointer to the field.
-    pub fn mut_oneof_decl(&mut self) -> &mut ::protobuf::RepeatedField<OneofDescriptorProto> {
+    pub fn mut_oneof_decl(&mut self) -> &mut crate::RepeatedField<OneofDescriptorProto> {
         &mut self.oneof_decl
     }
 
     // Take field
-    pub fn take_oneof_decl(&mut self) -> ::protobuf::RepeatedField<OneofDescriptorProto> {
-        ::std::mem::replace(&mut self.oneof_decl, ::protobuf::RepeatedField::new())
+    pub fn take_oneof_decl(&mut self) -> crate::RepeatedField<OneofDescriptorProto> {
+        ::std::mem::replace(&mut self.oneof_decl, crate::RepeatedField::new())
     }
 
     // optional .google.protobuf.MessageOptions options = 7;
 
 
     pub fn get_options(&self) -> &MessageOptions {
-        self.options.as_ref().unwrap_or_else(|| <MessageOptions as ::protobuf::Message>::default_instance())
+        self.options.as_ref().unwrap_or_else(|| <MessageOptions as crate::Message>::default_instance())
     }
     pub fn clear_options(&mut self) {
         self.options.clear();
@@ -1131,7 +1131,7 @@
 
     // Param is passed by value, moved
     pub fn set_options(&mut self, v: MessageOptions) {
-        self.options = ::protobuf::SingularPtrField::some(v);
+        self.options = crate::SingularPtrField::some(v);
     }
 
     // Mutable pointer to the field.
@@ -1159,18 +1159,18 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_reserved_range(&mut self, v: ::protobuf::RepeatedField<DescriptorProto_ReservedRange>) {
+    pub fn set_reserved_range(&mut self, v: crate::RepeatedField<DescriptorProto_ReservedRange>) {
         self.reserved_range = v;
     }
 
     // Mutable pointer to the field.
-    pub fn mut_reserved_range(&mut self) -> &mut ::protobuf::RepeatedField<DescriptorProto_ReservedRange> {
+    pub fn mut_reserved_range(&mut self) -> &mut crate::RepeatedField<DescriptorProto_ReservedRange> {
         &mut self.reserved_range
     }
 
     // Take field
-    pub fn take_reserved_range(&mut self) -> ::protobuf::RepeatedField<DescriptorProto_ReservedRange> {
-        ::std::mem::replace(&mut self.reserved_range, ::protobuf::RepeatedField::new())
+    pub fn take_reserved_range(&mut self) -> crate::RepeatedField<DescriptorProto_ReservedRange> {
+        ::std::mem::replace(&mut self.reserved_range, crate::RepeatedField::new())
     }
 
     // repeated string reserved_name = 10;
@@ -1184,22 +1184,22 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_reserved_name(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
+    pub fn set_reserved_name(&mut self, v: crate::RepeatedField<::std::string::String>) {
         self.reserved_name = v;
     }
 
     // Mutable pointer to the field.
-    pub fn mut_reserved_name(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
+    pub fn mut_reserved_name(&mut self) -> &mut crate::RepeatedField<::std::string::String> {
         &mut self.reserved_name
     }
 
     // Take field
-    pub fn take_reserved_name(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
-        ::std::mem::replace(&mut self.reserved_name, ::protobuf::RepeatedField::new())
+    pub fn take_reserved_name(&mut self) -> crate::RepeatedField<::std::string::String> {
+        ::std::mem::replace(&mut self.reserved_name, crate::RepeatedField::new())
     }
 }
 
-impl ::protobuf::Message for DescriptorProto {
+impl crate::Message for DescriptorProto {
     fn is_initialized(&self) -> bool {
         for v in &self.field {
             if !v.is_initialized() {
@@ -1244,42 +1244,42 @@
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
         while !is.eof()? {
             let (field_number, wire_type) = is.read_tag_unpack()?;
             match field_number {
                 1 => {
-                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.name)?;
+                    crate::rt::read_singular_string_into(wire_type, is, &mut self.name)?;
                 },
                 2 => {
-                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.field)?;
+                    crate::rt::read_repeated_message_into(wire_type, is, &mut self.field)?;
                 },
                 6 => {
-                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.extension)?;
+                    crate::rt::read_repeated_message_into(wire_type, is, &mut self.extension)?;
                 },
                 3 => {
-                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.nested_type)?;
+                    crate::rt::read_repeated_message_into(wire_type, is, &mut self.nested_type)?;
                 },
                 4 => {
-                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.enum_type)?;
+                    crate::rt::read_repeated_message_into(wire_type, is, &mut self.enum_type)?;
                 },
                 5 => {
-                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.extension_range)?;
+                    crate::rt::read_repeated_message_into(wire_type, is, &mut self.extension_range)?;
                 },
                 8 => {
-                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.oneof_decl)?;
+                    crate::rt::read_repeated_message_into(wire_type, is, &mut self.oneof_decl)?;
                 },
                 7 => {
-                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.options)?;
+                    crate::rt::read_singular_message_into(wire_type, is, &mut self.options)?;
                 },
                 9 => {
-                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.reserved_range)?;
+                    crate::rt::read_repeated_message_into(wire_type, is, &mut self.reserved_range)?;
                 },
                 10 => {
-                    ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.reserved_name)?;
+                    crate::rt::read_repeated_string_into(wire_type, is, &mut self.reserved_name)?;
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -1291,89 +1291,89 @@
     fn compute_size(&self) -> u32 {
         let mut my_size = 0;
         if let Some(ref v) = self.name.as_ref() {
-            my_size += ::protobuf::rt::string_size(1, &v);
+            my_size += crate::rt::string_size(1, &v);
         }
         for value in &self.field {
             let len = value.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
         };
         for value in &self.extension {
             let len = value.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
         };
         for value in &self.nested_type {
             let len = value.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
         };
         for value in &self.enum_type {
             let len = value.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
         };
         for value in &self.extension_range {
             let len = value.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
         };
         for value in &self.oneof_decl {
             let len = value.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
         };
         if let Some(ref v) = self.options.as_ref() {
             let len = v.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
         }
         for value in &self.reserved_range {
             let len = value.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
         };
         for value in &self.reserved_name {
-            my_size += ::protobuf::rt::string_size(10, &value);
+            my_size += crate::rt::string_size(10, &value);
         };
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         if let Some(ref v) = self.name.as_ref() {
             os.write_string(1, &v)?;
         }
         for v in &self.field {
-            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(2, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         };
         for v in &self.extension {
-            os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(6, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         };
         for v in &self.nested_type {
-            os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(3, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         };
         for v in &self.enum_type {
-            os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(4, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         };
         for v in &self.extension_range {
-            os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(5, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         };
         for v in &self.oneof_decl {
-            os.write_tag(8, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(8, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         };
         if let Some(ref v) = self.options.as_ref() {
-            os.write_tag(7, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(7, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         }
         for v in &self.reserved_range {
-            os.write_tag(9, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(9, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         };
@@ -1388,11 +1388,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -1406,7 +1406,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -1414,61 +1414,61 @@
         DescriptorProto::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "name",
                 |m: &DescriptorProto| { &m.name },
                 |m: &mut DescriptorProto| { &mut m.name },
             ));
-            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<FieldDescriptorProto>>(
+            fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<FieldDescriptorProto>>(
                 "field",
                 |m: &DescriptorProto| { &m.field },
                 |m: &mut DescriptorProto| { &mut m.field },
             ));
-            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<FieldDescriptorProto>>(
+            fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<FieldDescriptorProto>>(
                 "extension",
                 |m: &DescriptorProto| { &m.extension },
                 |m: &mut DescriptorProto| { &mut m.extension },
             ));
-            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<DescriptorProto>>(
+            fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<DescriptorProto>>(
                 "nested_type",
                 |m: &DescriptorProto| { &m.nested_type },
                 |m: &mut DescriptorProto| { &mut m.nested_type },
             ));
-            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<EnumDescriptorProto>>(
+            fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<EnumDescriptorProto>>(
                 "enum_type",
                 |m: &DescriptorProto| { &m.enum_type },
                 |m: &mut DescriptorProto| { &mut m.enum_type },
             ));
-            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<DescriptorProto_ExtensionRange>>(
+            fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<DescriptorProto_ExtensionRange>>(
                 "extension_range",
                 |m: &DescriptorProto| { &m.extension_range },
                 |m: &mut DescriptorProto| { &mut m.extension_range },
             ));
-            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<OneofDescriptorProto>>(
+            fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<OneofDescriptorProto>>(
                 "oneof_decl",
                 |m: &DescriptorProto| { &m.oneof_decl },
                 |m: &mut DescriptorProto| { &mut m.oneof_decl },
             ));
-            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<MessageOptions>>(
+            fields.push(crate::reflect::accessor::make_singular_ptr_field_accessor::<_, crate::types::ProtobufTypeMessage<MessageOptions>>(
                 "options",
                 |m: &DescriptorProto| { &m.options },
                 |m: &mut DescriptorProto| { &mut m.options },
             ));
-            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<DescriptorProto_ReservedRange>>(
+            fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<DescriptorProto_ReservedRange>>(
                 "reserved_range",
                 |m: &DescriptorProto| { &m.reserved_range },
                 |m: &mut DescriptorProto| { &mut m.reserved_range },
             ));
-            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "reserved_name",
                 |m: &DescriptorProto| { &m.reserved_name },
                 |m: &mut DescriptorProto| { &mut m.reserved_name },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<DescriptorProto>(
+            crate::reflect::MessageDescriptor::new_pb_name::<DescriptorProto>(
                 "DescriptorProto",
                 fields,
                 file_descriptor_proto()
@@ -1477,12 +1477,12 @@
     }
 
     fn default_instance() -> &'static DescriptorProto {
-        static instance: ::protobuf::rt::LazyV2<DescriptorProto> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<DescriptorProto> = crate::rt::LazyV2::INIT;
         instance.get(DescriptorProto::new)
     }
 }
 
-impl ::protobuf::Clear for DescriptorProto {
+impl crate::Clear for DescriptorProto {
     fn clear(&mut self) {
         self.name.clear();
         self.field.clear();
@@ -1500,13 +1500,13 @@
 
 impl ::std::fmt::Debug for DescriptorProto {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for DescriptorProto {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for DescriptorProto {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -1518,14 +1518,14 @@
     end: ::std::option::Option<i32>,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a DescriptorProto_ExtensionRange {
     fn default() -> &'a DescriptorProto_ExtensionRange {
-        <DescriptorProto_ExtensionRange as ::protobuf::Message>::default_instance()
+        <DescriptorProto_ExtensionRange as crate::Message>::default_instance()
     }
 }
 
@@ -1573,31 +1573,31 @@
     }
 }
 
-impl ::protobuf::Message for DescriptorProto_ExtensionRange {
+impl crate::Message for DescriptorProto_ExtensionRange {
     fn is_initialized(&self) -> bool {
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::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));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_int32()?;
                     self.start = ::std::option::Option::Some(tmp);
                 },
                 2 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_int32()?;
                     self.end = ::std::option::Option::Some(tmp);
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -1609,17 +1609,17 @@
     fn compute_size(&self) -> u32 {
         let mut my_size = 0;
         if let Some(v) = self.start {
-            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
+            my_size += crate::rt::value_size(1, v, crate::wire_format::WireTypeVarint);
         }
         if let Some(v) = self.end {
-            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
+            my_size += crate::rt::value_size(2, v, crate::wire_format::WireTypeVarint);
         }
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         if let Some(v) = self.start {
             os.write_int32(1, v)?;
         }
@@ -1634,11 +1634,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -1652,7 +1652,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -1660,21 +1660,21 @@
         DescriptorProto_ExtensionRange::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
+            fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeInt32>(
                 "start",
                 |m: &DescriptorProto_ExtensionRange| { &m.start },
                 |m: &mut DescriptorProto_ExtensionRange| { &mut m.start },
             ));
-            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
+            fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeInt32>(
                 "end",
                 |m: &DescriptorProto_ExtensionRange| { &m.end },
                 |m: &mut DescriptorProto_ExtensionRange| { &mut m.end },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<DescriptorProto_ExtensionRange>(
+            crate::reflect::MessageDescriptor::new_pb_name::<DescriptorProto_ExtensionRange>(
                 "DescriptorProto.ExtensionRange",
                 fields,
                 file_descriptor_proto()
@@ -1683,12 +1683,12 @@
     }
 
     fn default_instance() -> &'static DescriptorProto_ExtensionRange {
-        static instance: ::protobuf::rt::LazyV2<DescriptorProto_ExtensionRange> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<DescriptorProto_ExtensionRange> = crate::rt::LazyV2::INIT;
         instance.get(DescriptorProto_ExtensionRange::new)
     }
 }
 
-impl ::protobuf::Clear for DescriptorProto_ExtensionRange {
+impl crate::Clear for DescriptorProto_ExtensionRange {
     fn clear(&mut self) {
         self.start = ::std::option::Option::None;
         self.end = ::std::option::Option::None;
@@ -1698,13 +1698,13 @@
 
 impl ::std::fmt::Debug for DescriptorProto_ExtensionRange {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for DescriptorProto_ExtensionRange {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for DescriptorProto_ExtensionRange {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -1716,14 +1716,14 @@
     end: ::std::option::Option<i32>,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a DescriptorProto_ReservedRange {
     fn default() -> &'a DescriptorProto_ReservedRange {
-        <DescriptorProto_ReservedRange as ::protobuf::Message>::default_instance()
+        <DescriptorProto_ReservedRange as crate::Message>::default_instance()
     }
 }
 
@@ -1771,31 +1771,31 @@
     }
 }
 
-impl ::protobuf::Message for DescriptorProto_ReservedRange {
+impl crate::Message for DescriptorProto_ReservedRange {
     fn is_initialized(&self) -> bool {
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::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));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_int32()?;
                     self.start = ::std::option::Option::Some(tmp);
                 },
                 2 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_int32()?;
                     self.end = ::std::option::Option::Some(tmp);
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -1807,17 +1807,17 @@
     fn compute_size(&self) -> u32 {
         let mut my_size = 0;
         if let Some(v) = self.start {
-            my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
+            my_size += crate::rt::value_size(1, v, crate::wire_format::WireTypeVarint);
         }
         if let Some(v) = self.end {
-            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
+            my_size += crate::rt::value_size(2, v, crate::wire_format::WireTypeVarint);
         }
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         if let Some(v) = self.start {
             os.write_int32(1, v)?;
         }
@@ -1832,11 +1832,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -1850,7 +1850,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -1858,21 +1858,21 @@
         DescriptorProto_ReservedRange::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
+            fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeInt32>(
                 "start",
                 |m: &DescriptorProto_ReservedRange| { &m.start },
                 |m: &mut DescriptorProto_ReservedRange| { &mut m.start },
             ));
-            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
+            fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeInt32>(
                 "end",
                 |m: &DescriptorProto_ReservedRange| { &m.end },
                 |m: &mut DescriptorProto_ReservedRange| { &mut m.end },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<DescriptorProto_ReservedRange>(
+            crate::reflect::MessageDescriptor::new_pb_name::<DescriptorProto_ReservedRange>(
                 "DescriptorProto.ReservedRange",
                 fields,
                 file_descriptor_proto()
@@ -1881,12 +1881,12 @@
     }
 
     fn default_instance() -> &'static DescriptorProto_ReservedRange {
-        static instance: ::protobuf::rt::LazyV2<DescriptorProto_ReservedRange> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<DescriptorProto_ReservedRange> = crate::rt::LazyV2::INIT;
         instance.get(DescriptorProto_ReservedRange::new)
     }
 }
 
-impl ::protobuf::Clear for DescriptorProto_ReservedRange {
+impl crate::Clear for DescriptorProto_ReservedRange {
     fn clear(&mut self) {
         self.start = ::std::option::Option::None;
         self.end = ::std::option::Option::None;
@@ -1896,13 +1896,13 @@
 
 impl ::std::fmt::Debug for DescriptorProto_ReservedRange {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for DescriptorProto_ReservedRange {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for DescriptorProto_ReservedRange {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -1910,26 +1910,26 @@
 #[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
 pub struct FieldDescriptorProto {
     // message fields
-    name: ::protobuf::SingularField<::std::string::String>,
+    name: crate::SingularField<::std::string::String>,
     number: ::std::option::Option<i32>,
     label: ::std::option::Option<FieldDescriptorProto_Label>,
     field_type: ::std::option::Option<FieldDescriptorProto_Type>,
-    type_name: ::protobuf::SingularField<::std::string::String>,
-    extendee: ::protobuf::SingularField<::std::string::String>,
-    default_value: ::protobuf::SingularField<::std::string::String>,
+    type_name: crate::SingularField<::std::string::String>,
+    extendee: crate::SingularField<::std::string::String>,
+    default_value: crate::SingularField<::std::string::String>,
     oneof_index: ::std::option::Option<i32>,
-    json_name: ::protobuf::SingularField<::std::string::String>,
-    pub options: ::protobuf::SingularPtrField<FieldOptions>,
+    json_name: crate::SingularField<::std::string::String>,
+    pub options: crate::SingularPtrField<FieldOptions>,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a FieldDescriptorProto {
     fn default() -> &'a FieldDescriptorProto {
-        <FieldDescriptorProto as ::protobuf::Message>::default_instance()
+        <FieldDescriptorProto as crate::Message>::default_instance()
     }
 }
 
@@ -1957,7 +1957,7 @@
 
     // Param is passed by value, moved
     pub fn set_name(&mut self, v: ::std::string::String) {
-        self.name = ::protobuf::SingularField::some(v);
+        self.name = crate::SingularField::some(v);
     }
 
     // Mutable pointer to the field.
@@ -2050,7 +2050,7 @@
 
     // Param is passed by value, moved
     pub fn set_type_name(&mut self, v: ::std::string::String) {
-        self.type_name = ::protobuf::SingularField::some(v);
+        self.type_name = crate::SingularField::some(v);
     }
 
     // Mutable pointer to the field.
@@ -2086,7 +2086,7 @@
 
     // Param is passed by value, moved
     pub fn set_extendee(&mut self, v: ::std::string::String) {
-        self.extendee = ::protobuf::SingularField::some(v);
+        self.extendee = crate::SingularField::some(v);
     }
 
     // Mutable pointer to the field.
@@ -2122,7 +2122,7 @@
 
     // Param is passed by value, moved
     pub fn set_default_value(&mut self, v: ::std::string::String) {
-        self.default_value = ::protobuf::SingularField::some(v);
+        self.default_value = crate::SingularField::some(v);
     }
 
     // Mutable pointer to the field.
@@ -2177,7 +2177,7 @@
 
     // Param is passed by value, moved
     pub fn set_json_name(&mut self, v: ::std::string::String) {
-        self.json_name = ::protobuf::SingularField::some(v);
+        self.json_name = crate::SingularField::some(v);
     }
 
     // Mutable pointer to the field.
@@ -2198,7 +2198,7 @@
 
 
     pub fn get_options(&self) -> &FieldOptions {
-        self.options.as_ref().unwrap_or_else(|| <FieldOptions as ::protobuf::Message>::default_instance())
+        self.options.as_ref().unwrap_or_else(|| <FieldOptions as crate::Message>::default_instance())
     }
     pub fn clear_options(&mut self) {
         self.options.clear();
@@ -2210,7 +2210,7 @@
 
     // Param is passed by value, moved
     pub fn set_options(&mut self, v: FieldOptions) {
-        self.options = ::protobuf::SingularPtrField::some(v);
+        self.options = crate::SingularPtrField::some(v);
     }
 
     // Mutable pointer to the field.
@@ -2228,7 +2228,7 @@
     }
 }
 
-impl ::protobuf::Message for FieldDescriptorProto {
+impl crate::Message for FieldDescriptorProto {
     fn is_initialized(&self) -> bool {
         for v in &self.options {
             if !v.is_initialized() {
@@ -2238,50 +2238,50 @@
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
         while !is.eof()? {
             let (field_number, wire_type) = is.read_tag_unpack()?;
             match field_number {
                 1 => {
-                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.name)?;
+                    crate::rt::read_singular_string_into(wire_type, is, &mut self.name)?;
                 },
                 3 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_int32()?;
                     self.number = ::std::option::Option::Some(tmp);
                 },
                 4 => {
-                    ::protobuf::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.label, 4, &mut self.unknown_fields)?
+                    crate::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.label, 4, &mut self.unknown_fields)?
                 },
                 5 => {
-                    ::protobuf::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.field_type, 5, &mut self.unknown_fields)?
+                    crate::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.field_type, 5, &mut self.unknown_fields)?
                 },
                 6 => {
-                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.type_name)?;
+                    crate::rt::read_singular_string_into(wire_type, is, &mut self.type_name)?;
                 },
                 2 => {
-                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.extendee)?;
+                    crate::rt::read_singular_string_into(wire_type, is, &mut self.extendee)?;
                 },
                 7 => {
-                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.default_value)?;
+                    crate::rt::read_singular_string_into(wire_type, is, &mut self.default_value)?;
                 },
                 9 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_int32()?;
                     self.oneof_index = ::std::option::Option::Some(tmp);
                 },
                 10 => {
-                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.json_name)?;
+                    crate::rt::read_singular_string_into(wire_type, is, &mut self.json_name)?;
                 },
                 8 => {
-                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.options)?;
+                    crate::rt::read_singular_message_into(wire_type, is, &mut self.options)?;
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -2293,42 +2293,42 @@
     fn compute_size(&self) -> u32 {
         let mut my_size = 0;
         if let Some(ref v) = self.name.as_ref() {
-            my_size += ::protobuf::rt::string_size(1, &v);
+            my_size += crate::rt::string_size(1, &v);
         }
         if let Some(v) = self.number {
-            my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
+            my_size += crate::rt::value_size(3, v, crate::wire_format::WireTypeVarint);
         }
         if let Some(v) = self.label {
-            my_size += ::protobuf::rt::enum_size(4, v);
+            my_size += crate::rt::enum_size(4, v);
         }
         if let Some(v) = self.field_type {
-            my_size += ::protobuf::rt::enum_size(5, v);
+            my_size += crate::rt::enum_size(5, v);
         }
         if let Some(ref v) = self.type_name.as_ref() {
-            my_size += ::protobuf::rt::string_size(6, &v);
+            my_size += crate::rt::string_size(6, &v);
         }
         if let Some(ref v) = self.extendee.as_ref() {
-            my_size += ::protobuf::rt::string_size(2, &v);
+            my_size += crate::rt::string_size(2, &v);
         }
         if let Some(ref v) = self.default_value.as_ref() {
-            my_size += ::protobuf::rt::string_size(7, &v);
+            my_size += crate::rt::string_size(7, &v);
         }
         if let Some(v) = self.oneof_index {
-            my_size += ::protobuf::rt::value_size(9, v, ::protobuf::wire_format::WireTypeVarint);
+            my_size += crate::rt::value_size(9, v, crate::wire_format::WireTypeVarint);
         }
         if let Some(ref v) = self.json_name.as_ref() {
-            my_size += ::protobuf::rt::string_size(10, &v);
+            my_size += crate::rt::string_size(10, &v);
         }
         if let Some(ref v) = self.options.as_ref() {
             let len = v.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
         }
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         if let Some(ref v) = self.name.as_ref() {
             os.write_string(1, &v)?;
         }
@@ -2336,10 +2336,10 @@
             os.write_int32(3, v)?;
         }
         if let Some(v) = self.label {
-            os.write_enum(4, ::protobuf::ProtobufEnum::value(&v))?;
+            os.write_enum(4, crate::ProtobufEnum::value(&v))?;
         }
         if let Some(v) = self.field_type {
-            os.write_enum(5, ::protobuf::ProtobufEnum::value(&v))?;
+            os.write_enum(5, crate::ProtobufEnum::value(&v))?;
         }
         if let Some(ref v) = self.type_name.as_ref() {
             os.write_string(6, &v)?;
@@ -2357,7 +2357,7 @@
             os.write_string(10, &v)?;
         }
         if let Some(ref v) = self.options.as_ref() {
-            os.write_tag(8, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(8, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         }
@@ -2369,11 +2369,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -2387,7 +2387,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -2395,61 +2395,61 @@
         FieldDescriptorProto::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "name",
                 |m: &FieldDescriptorProto| { &m.name },
                 |m: &mut FieldDescriptorProto| { &mut m.name },
             ));
-            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
+            fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeInt32>(
                 "number",
                 |m: &FieldDescriptorProto| { &m.number },
                 |m: &mut FieldDescriptorProto| { &mut m.number },
             ));
-            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<FieldDescriptorProto_Label>>(
+            fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeEnum<FieldDescriptorProto_Label>>(
                 "label",
                 |m: &FieldDescriptorProto| { &m.label },
                 |m: &mut FieldDescriptorProto| { &mut m.label },
             ));
-            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<FieldDescriptorProto_Type>>(
+            fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeEnum<FieldDescriptorProto_Type>>(
                 "type",
                 |m: &FieldDescriptorProto| { &m.field_type },
                 |m: &mut FieldDescriptorProto| { &mut m.field_type },
             ));
-            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "type_name",
                 |m: &FieldDescriptorProto| { &m.type_name },
                 |m: &mut FieldDescriptorProto| { &mut m.type_name },
             ));
-            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "extendee",
                 |m: &FieldDescriptorProto| { &m.extendee },
                 |m: &mut FieldDescriptorProto| { &mut m.extendee },
             ));
-            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "default_value",
                 |m: &FieldDescriptorProto| { &m.default_value },
                 |m: &mut FieldDescriptorProto| { &mut m.default_value },
             ));
-            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
+            fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeInt32>(
                 "oneof_index",
                 |m: &FieldDescriptorProto| { &m.oneof_index },
                 |m: &mut FieldDescriptorProto| { &mut m.oneof_index },
             ));
-            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "json_name",
                 |m: &FieldDescriptorProto| { &m.json_name },
                 |m: &mut FieldDescriptorProto| { &mut m.json_name },
             ));
-            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<FieldOptions>>(
+            fields.push(crate::reflect::accessor::make_singular_ptr_field_accessor::<_, crate::types::ProtobufTypeMessage<FieldOptions>>(
                 "options",
                 |m: &FieldDescriptorProto| { &m.options },
                 |m: &mut FieldDescriptorProto| { &mut m.options },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<FieldDescriptorProto>(
+            crate::reflect::MessageDescriptor::new_pb_name::<FieldDescriptorProto>(
                 "FieldDescriptorProto",
                 fields,
                 file_descriptor_proto()
@@ -2458,12 +2458,12 @@
     }
 
     fn default_instance() -> &'static FieldDescriptorProto {
-        static instance: ::protobuf::rt::LazyV2<FieldDescriptorProto> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<FieldDescriptorProto> = crate::rt::LazyV2::INIT;
         instance.get(FieldDescriptorProto::new)
     }
 }
 
-impl ::protobuf::Clear for FieldDescriptorProto {
+impl crate::Clear for FieldDescriptorProto {
     fn clear(&mut self) {
         self.name.clear();
         self.number = ::std::option::Option::None;
@@ -2481,13 +2481,13 @@
 
 impl ::std::fmt::Debug for FieldDescriptorProto {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for FieldDescriptorProto {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for FieldDescriptorProto {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -2514,7 +2514,7 @@
     TYPE_SINT64 = 18,
 }
 
-impl ::protobuf::ProtobufEnum for FieldDescriptorProto_Type {
+impl crate::ProtobufEnum for FieldDescriptorProto_Type {
     fn value(&self) -> i32 {
         *self as i32
     }
@@ -2567,10 +2567,10 @@
         values
     }
 
-    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn enum_descriptor_static() -> &'static crate::reflect::EnumDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::EnumDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
-            ::protobuf::reflect::EnumDescriptor::new_pb_name::<FieldDescriptorProto_Type>("FieldDescriptorProto.Type", file_descriptor_proto())
+            crate::reflect::EnumDescriptor::new_pb_name::<FieldDescriptorProto_Type>("FieldDescriptorProto.Type", file_descriptor_proto())
         })
     }
 }
@@ -2585,9 +2585,9 @@
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for FieldDescriptorProto_Type {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
+impl crate::reflect::ProtobufValue for FieldDescriptorProto_Type {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Enum(crate::ProtobufEnum::descriptor(self))
     }
 }
 
@@ -2599,7 +2599,7 @@
     LABEL_REPEATED = 3,
 }
 
-impl ::protobuf::ProtobufEnum for FieldDescriptorProto_Label {
+impl crate::ProtobufEnum for FieldDescriptorProto_Label {
     fn value(&self) -> i32 {
         *self as i32
     }
@@ -2622,10 +2622,10 @@
         values
     }
 
-    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn enum_descriptor_static() -> &'static crate::reflect::EnumDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::EnumDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
-            ::protobuf::reflect::EnumDescriptor::new_pb_name::<FieldDescriptorProto_Label>("FieldDescriptorProto.Label", file_descriptor_proto())
+            crate::reflect::EnumDescriptor::new_pb_name::<FieldDescriptorProto_Label>("FieldDescriptorProto.Label", file_descriptor_proto())
         })
     }
 }
@@ -2640,9 +2640,9 @@
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for FieldDescriptorProto_Label {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
+impl crate::reflect::ProtobufValue for FieldDescriptorProto_Label {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Enum(crate::ProtobufEnum::descriptor(self))
     }
 }
 
@@ -2650,18 +2650,18 @@
 #[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
 pub struct OneofDescriptorProto {
     // message fields
-    name: ::protobuf::SingularField<::std::string::String>,
-    pub options: ::protobuf::SingularPtrField<OneofOptions>,
+    name: crate::SingularField<::std::string::String>,
+    pub options: crate::SingularPtrField<OneofOptions>,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a OneofDescriptorProto {
     fn default() -> &'a OneofDescriptorProto {
-        <OneofDescriptorProto as ::protobuf::Message>::default_instance()
+        <OneofDescriptorProto as crate::Message>::default_instance()
     }
 }
 
@@ -2689,7 +2689,7 @@
 
     // Param is passed by value, moved
     pub fn set_name(&mut self, v: ::std::string::String) {
-        self.name = ::protobuf::SingularField::some(v);
+        self.name = crate::SingularField::some(v);
     }
 
     // Mutable pointer to the field.
@@ -2710,7 +2710,7 @@
 
 
     pub fn get_options(&self) -> &OneofOptions {
-        self.options.as_ref().unwrap_or_else(|| <OneofOptions as ::protobuf::Message>::default_instance())
+        self.options.as_ref().unwrap_or_else(|| <OneofOptions as crate::Message>::default_instance())
     }
     pub fn clear_options(&mut self) {
         self.options.clear();
@@ -2722,7 +2722,7 @@
 
     // Param is passed by value, moved
     pub fn set_options(&mut self, v: OneofOptions) {
-        self.options = ::protobuf::SingularPtrField::some(v);
+        self.options = crate::SingularPtrField::some(v);
     }
 
     // Mutable pointer to the field.
@@ -2740,7 +2740,7 @@
     }
 }
 
-impl ::protobuf::Message for OneofDescriptorProto {
+impl crate::Message for OneofDescriptorProto {
     fn is_initialized(&self) -> bool {
         for v in &self.options {
             if !v.is_initialized() {
@@ -2750,18 +2750,18 @@
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
         while !is.eof()? {
             let (field_number, wire_type) = is.read_tag_unpack()?;
             match field_number {
                 1 => {
-                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.name)?;
+                    crate::rt::read_singular_string_into(wire_type, is, &mut self.name)?;
                 },
                 2 => {
-                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.options)?;
+                    crate::rt::read_singular_message_into(wire_type, is, &mut self.options)?;
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -2773,23 +2773,23 @@
     fn compute_size(&self) -> u32 {
         let mut my_size = 0;
         if let Some(ref v) = self.name.as_ref() {
-            my_size += ::protobuf::rt::string_size(1, &v);
+            my_size += crate::rt::string_size(1, &v);
         }
         if let Some(ref v) = self.options.as_ref() {
             let len = v.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
         }
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         if let Some(ref v) = self.name.as_ref() {
             os.write_string(1, &v)?;
         }
         if let Some(ref v) = self.options.as_ref() {
-            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(2, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         }
@@ -2801,11 +2801,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -2819,7 +2819,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -2827,21 +2827,21 @@
         OneofDescriptorProto::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "name",
                 |m: &OneofDescriptorProto| { &m.name },
                 |m: &mut OneofDescriptorProto| { &mut m.name },
             ));
-            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<OneofOptions>>(
+            fields.push(crate::reflect::accessor::make_singular_ptr_field_accessor::<_, crate::types::ProtobufTypeMessage<OneofOptions>>(
                 "options",
                 |m: &OneofDescriptorProto| { &m.options },
                 |m: &mut OneofDescriptorProto| { &mut m.options },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<OneofDescriptorProto>(
+            crate::reflect::MessageDescriptor::new_pb_name::<OneofDescriptorProto>(
                 "OneofDescriptorProto",
                 fields,
                 file_descriptor_proto()
@@ -2850,12 +2850,12 @@
     }
 
     fn default_instance() -> &'static OneofDescriptorProto {
-        static instance: ::protobuf::rt::LazyV2<OneofDescriptorProto> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<OneofDescriptorProto> = crate::rt::LazyV2::INIT;
         instance.get(OneofDescriptorProto::new)
     }
 }
 
-impl ::protobuf::Clear for OneofDescriptorProto {
+impl crate::Clear for OneofDescriptorProto {
     fn clear(&mut self) {
         self.name.clear();
         self.options.clear();
@@ -2865,13 +2865,13 @@
 
 impl ::std::fmt::Debug for OneofDescriptorProto {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for OneofDescriptorProto {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for OneofDescriptorProto {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -2879,19 +2879,19 @@
 #[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
 pub struct EnumDescriptorProto {
     // message fields
-    name: ::protobuf::SingularField<::std::string::String>,
-    pub value: ::protobuf::RepeatedField<EnumValueDescriptorProto>,
-    pub options: ::protobuf::SingularPtrField<EnumOptions>,
+    name: crate::SingularField<::std::string::String>,
+    pub value: crate::RepeatedField<EnumValueDescriptorProto>,
+    pub options: crate::SingularPtrField<EnumOptions>,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a EnumDescriptorProto {
     fn default() -> &'a EnumDescriptorProto {
-        <EnumDescriptorProto as ::protobuf::Message>::default_instance()
+        <EnumDescriptorProto as crate::Message>::default_instance()
     }
 }
 
@@ -2919,7 +2919,7 @@
 
     // Param is passed by value, moved
     pub fn set_name(&mut self, v: ::std::string::String) {
-        self.name = ::protobuf::SingularField::some(v);
+        self.name = crate::SingularField::some(v);
     }
 
     // Mutable pointer to the field.
@@ -2947,25 +2947,25 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_value(&mut self, v: ::protobuf::RepeatedField<EnumValueDescriptorProto>) {
+    pub fn set_value(&mut self, v: crate::RepeatedField<EnumValueDescriptorProto>) {
         self.value = v;
     }
 
     // Mutable pointer to the field.
-    pub fn mut_value(&mut self) -> &mut ::protobuf::RepeatedField<EnumValueDescriptorProto> {
+    pub fn mut_value(&mut self) -> &mut crate::RepeatedField<EnumValueDescriptorProto> {
         &mut self.value
     }
 
     // Take field
-    pub fn take_value(&mut self) -> ::protobuf::RepeatedField<EnumValueDescriptorProto> {
-        ::std::mem::replace(&mut self.value, ::protobuf::RepeatedField::new())
+    pub fn take_value(&mut self) -> crate::RepeatedField<EnumValueDescriptorProto> {
+        ::std::mem::replace(&mut self.value, crate::RepeatedField::new())
     }
 
     // optional .google.protobuf.EnumOptions options = 3;
 
 
     pub fn get_options(&self) -> &EnumOptions {
-        self.options.as_ref().unwrap_or_else(|| <EnumOptions as ::protobuf::Message>::default_instance())
+        self.options.as_ref().unwrap_or_else(|| <EnumOptions as crate::Message>::default_instance())
     }
     pub fn clear_options(&mut self) {
         self.options.clear();
@@ -2977,7 +2977,7 @@
 
     // Param is passed by value, moved
     pub fn set_options(&mut self, v: EnumOptions) {
-        self.options = ::protobuf::SingularPtrField::some(v);
+        self.options = crate::SingularPtrField::some(v);
     }
 
     // Mutable pointer to the field.
@@ -2995,7 +2995,7 @@
     }
 }
 
-impl ::protobuf::Message for EnumDescriptorProto {
+impl crate::Message for EnumDescriptorProto {
     fn is_initialized(&self) -> bool {
         for v in &self.value {
             if !v.is_initialized() {
@@ -3010,21 +3010,21 @@
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
         while !is.eof()? {
             let (field_number, wire_type) = is.read_tag_unpack()?;
             match field_number {
                 1 => {
-                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.name)?;
+                    crate::rt::read_singular_string_into(wire_type, is, &mut self.name)?;
                 },
                 2 => {
-                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.value)?;
+                    crate::rt::read_repeated_message_into(wire_type, is, &mut self.value)?;
                 },
                 3 => {
-                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.options)?;
+                    crate::rt::read_singular_message_into(wire_type, is, &mut self.options)?;
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -3036,32 +3036,32 @@
     fn compute_size(&self) -> u32 {
         let mut my_size = 0;
         if let Some(ref v) = self.name.as_ref() {
-            my_size += ::protobuf::rt::string_size(1, &v);
+            my_size += crate::rt::string_size(1, &v);
         }
         for value in &self.value {
             let len = value.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
         };
         if let Some(ref v) = self.options.as_ref() {
             let len = v.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
         }
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         if let Some(ref v) = self.name.as_ref() {
             os.write_string(1, &v)?;
         }
         for v in &self.value {
-            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(2, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         };
         if let Some(ref v) = self.options.as_ref() {
-            os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(3, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         }
@@ -3073,11 +3073,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -3091,7 +3091,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -3099,26 +3099,26 @@
         EnumDescriptorProto::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "name",
                 |m: &EnumDescriptorProto| { &m.name },
                 |m: &mut EnumDescriptorProto| { &mut m.name },
             ));
-            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<EnumValueDescriptorProto>>(
+            fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<EnumValueDescriptorProto>>(
                 "value",
                 |m: &EnumDescriptorProto| { &m.value },
                 |m: &mut EnumDescriptorProto| { &mut m.value },
             ));
-            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<EnumOptions>>(
+            fields.push(crate::reflect::accessor::make_singular_ptr_field_accessor::<_, crate::types::ProtobufTypeMessage<EnumOptions>>(
                 "options",
                 |m: &EnumDescriptorProto| { &m.options },
                 |m: &mut EnumDescriptorProto| { &mut m.options },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<EnumDescriptorProto>(
+            crate::reflect::MessageDescriptor::new_pb_name::<EnumDescriptorProto>(
                 "EnumDescriptorProto",
                 fields,
                 file_descriptor_proto()
@@ -3127,12 +3127,12 @@
     }
 
     fn default_instance() -> &'static EnumDescriptorProto {
-        static instance: ::protobuf::rt::LazyV2<EnumDescriptorProto> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<EnumDescriptorProto> = crate::rt::LazyV2::INIT;
         instance.get(EnumDescriptorProto::new)
     }
 }
 
-impl ::protobuf::Clear for EnumDescriptorProto {
+impl crate::Clear for EnumDescriptorProto {
     fn clear(&mut self) {
         self.name.clear();
         self.value.clear();
@@ -3143,13 +3143,13 @@
 
 impl ::std::fmt::Debug for EnumDescriptorProto {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for EnumDescriptorProto {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for EnumDescriptorProto {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -3157,19 +3157,19 @@
 #[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
 pub struct EnumValueDescriptorProto {
     // message fields
-    name: ::protobuf::SingularField<::std::string::String>,
+    name: crate::SingularField<::std::string::String>,
     number: ::std::option::Option<i32>,
-    pub options: ::protobuf::SingularPtrField<EnumValueOptions>,
+    pub options: crate::SingularPtrField<EnumValueOptions>,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a EnumValueDescriptorProto {
     fn default() -> &'a EnumValueDescriptorProto {
-        <EnumValueDescriptorProto as ::protobuf::Message>::default_instance()
+        <EnumValueDescriptorProto as crate::Message>::default_instance()
     }
 }
 
@@ -3197,7 +3197,7 @@
 
     // Param is passed by value, moved
     pub fn set_name(&mut self, v: ::std::string::String) {
-        self.name = ::protobuf::SingularField::some(v);
+        self.name = crate::SingularField::some(v);
     }
 
     // Mutable pointer to the field.
@@ -3237,7 +3237,7 @@
 
 
     pub fn get_options(&self) -> &EnumValueOptions {
-        self.options.as_ref().unwrap_or_else(|| <EnumValueOptions as ::protobuf::Message>::default_instance())
+        self.options.as_ref().unwrap_or_else(|| <EnumValueOptions as crate::Message>::default_instance())
     }
     pub fn clear_options(&mut self) {
         self.options.clear();
@@ -3249,7 +3249,7 @@
 
     // Param is passed by value, moved
     pub fn set_options(&mut self, v: EnumValueOptions) {
-        self.options = ::protobuf::SingularPtrField::some(v);
+        self.options = crate::SingularPtrField::some(v);
     }
 
     // Mutable pointer to the field.
@@ -3267,7 +3267,7 @@
     }
 }
 
-impl ::protobuf::Message for EnumValueDescriptorProto {
+impl crate::Message for EnumValueDescriptorProto {
     fn is_initialized(&self) -> bool {
         for v in &self.options {
             if !v.is_initialized() {
@@ -3277,25 +3277,25 @@
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
         while !is.eof()? {
             let (field_number, wire_type) = is.read_tag_unpack()?;
             match field_number {
                 1 => {
-                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.name)?;
+                    crate::rt::read_singular_string_into(wire_type, is, &mut self.name)?;
                 },
                 2 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_int32()?;
                     self.number = ::std::option::Option::Some(tmp);
                 },
                 3 => {
-                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.options)?;
+                    crate::rt::read_singular_message_into(wire_type, is, &mut self.options)?;
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -3307,21 +3307,21 @@
     fn compute_size(&self) -> u32 {
         let mut my_size = 0;
         if let Some(ref v) = self.name.as_ref() {
-            my_size += ::protobuf::rt::string_size(1, &v);
+            my_size += crate::rt::string_size(1, &v);
         }
         if let Some(v) = self.number {
-            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
+            my_size += crate::rt::value_size(2, v, crate::wire_format::WireTypeVarint);
         }
         if let Some(ref v) = self.options.as_ref() {
             let len = v.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
         }
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         if let Some(ref v) = self.name.as_ref() {
             os.write_string(1, &v)?;
         }
@@ -3329,7 +3329,7 @@
             os.write_int32(2, v)?;
         }
         if let Some(ref v) = self.options.as_ref() {
-            os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(3, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         }
@@ -3341,11 +3341,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -3359,7 +3359,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -3367,26 +3367,26 @@
         EnumValueDescriptorProto::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "name",
                 |m: &EnumValueDescriptorProto| { &m.name },
                 |m: &mut EnumValueDescriptorProto| { &mut m.name },
             ));
-            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
+            fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeInt32>(
                 "number",
                 |m: &EnumValueDescriptorProto| { &m.number },
                 |m: &mut EnumValueDescriptorProto| { &mut m.number },
             ));
-            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<EnumValueOptions>>(
+            fields.push(crate::reflect::accessor::make_singular_ptr_field_accessor::<_, crate::types::ProtobufTypeMessage<EnumValueOptions>>(
                 "options",
                 |m: &EnumValueDescriptorProto| { &m.options },
                 |m: &mut EnumValueDescriptorProto| { &mut m.options },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<EnumValueDescriptorProto>(
+            crate::reflect::MessageDescriptor::new_pb_name::<EnumValueDescriptorProto>(
                 "EnumValueDescriptorProto",
                 fields,
                 file_descriptor_proto()
@@ -3395,12 +3395,12 @@
     }
 
     fn default_instance() -> &'static EnumValueDescriptorProto {
-        static instance: ::protobuf::rt::LazyV2<EnumValueDescriptorProto> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<EnumValueDescriptorProto> = crate::rt::LazyV2::INIT;
         instance.get(EnumValueDescriptorProto::new)
     }
 }
 
-impl ::protobuf::Clear for EnumValueDescriptorProto {
+impl crate::Clear for EnumValueDescriptorProto {
     fn clear(&mut self) {
         self.name.clear();
         self.number = ::std::option::Option::None;
@@ -3411,13 +3411,13 @@
 
 impl ::std::fmt::Debug for EnumValueDescriptorProto {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for EnumValueDescriptorProto {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for EnumValueDescriptorProto {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -3425,19 +3425,19 @@
 #[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
 pub struct ServiceDescriptorProto {
     // message fields
-    name: ::protobuf::SingularField<::std::string::String>,
-    pub method: ::protobuf::RepeatedField<MethodDescriptorProto>,
-    pub options: ::protobuf::SingularPtrField<ServiceOptions>,
+    name: crate::SingularField<::std::string::String>,
+    pub method: crate::RepeatedField<MethodDescriptorProto>,
+    pub options: crate::SingularPtrField<ServiceOptions>,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a ServiceDescriptorProto {
     fn default() -> &'a ServiceDescriptorProto {
-        <ServiceDescriptorProto as ::protobuf::Message>::default_instance()
+        <ServiceDescriptorProto as crate::Message>::default_instance()
     }
 }
 
@@ -3465,7 +3465,7 @@
 
     // Param is passed by value, moved
     pub fn set_name(&mut self, v: ::std::string::String) {
-        self.name = ::protobuf::SingularField::some(v);
+        self.name = crate::SingularField::some(v);
     }
 
     // Mutable pointer to the field.
@@ -3493,25 +3493,25 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_method(&mut self, v: ::protobuf::RepeatedField<MethodDescriptorProto>) {
+    pub fn set_method(&mut self, v: crate::RepeatedField<MethodDescriptorProto>) {
         self.method = v;
     }
 
     // Mutable pointer to the field.
-    pub fn mut_method(&mut self) -> &mut ::protobuf::RepeatedField<MethodDescriptorProto> {
+    pub fn mut_method(&mut self) -> &mut crate::RepeatedField<MethodDescriptorProto> {
         &mut self.method
     }
 
     // Take field
-    pub fn take_method(&mut self) -> ::protobuf::RepeatedField<MethodDescriptorProto> {
-        ::std::mem::replace(&mut self.method, ::protobuf::RepeatedField::new())
+    pub fn take_method(&mut self) -> crate::RepeatedField<MethodDescriptorProto> {
+        ::std::mem::replace(&mut self.method, crate::RepeatedField::new())
     }
 
     // optional .google.protobuf.ServiceOptions options = 3;
 
 
     pub fn get_options(&self) -> &ServiceOptions {
-        self.options.as_ref().unwrap_or_else(|| <ServiceOptions as ::protobuf::Message>::default_instance())
+        self.options.as_ref().unwrap_or_else(|| <ServiceOptions as crate::Message>::default_instance())
     }
     pub fn clear_options(&mut self) {
         self.options.clear();
@@ -3523,7 +3523,7 @@
 
     // Param is passed by value, moved
     pub fn set_options(&mut self, v: ServiceOptions) {
-        self.options = ::protobuf::SingularPtrField::some(v);
+        self.options = crate::SingularPtrField::some(v);
     }
 
     // Mutable pointer to the field.
@@ -3541,7 +3541,7 @@
     }
 }
 
-impl ::protobuf::Message for ServiceDescriptorProto {
+impl crate::Message for ServiceDescriptorProto {
     fn is_initialized(&self) -> bool {
         for v in &self.method {
             if !v.is_initialized() {
@@ -3556,21 +3556,21 @@
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
         while !is.eof()? {
             let (field_number, wire_type) = is.read_tag_unpack()?;
             match field_number {
                 1 => {
-                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.name)?;
+                    crate::rt::read_singular_string_into(wire_type, is, &mut self.name)?;
                 },
                 2 => {
-                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.method)?;
+                    crate::rt::read_repeated_message_into(wire_type, is, &mut self.method)?;
                 },
                 3 => {
-                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.options)?;
+                    crate::rt::read_singular_message_into(wire_type, is, &mut self.options)?;
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -3582,32 +3582,32 @@
     fn compute_size(&self) -> u32 {
         let mut my_size = 0;
         if let Some(ref v) = self.name.as_ref() {
-            my_size += ::protobuf::rt::string_size(1, &v);
+            my_size += crate::rt::string_size(1, &v);
         }
         for value in &self.method {
             let len = value.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
         };
         if let Some(ref v) = self.options.as_ref() {
             let len = v.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
         }
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         if let Some(ref v) = self.name.as_ref() {
             os.write_string(1, &v)?;
         }
         for v in &self.method {
-            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(2, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         };
         if let Some(ref v) = self.options.as_ref() {
-            os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(3, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         }
@@ -3619,11 +3619,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -3637,7 +3637,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -3645,26 +3645,26 @@
         ServiceDescriptorProto::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "name",
                 |m: &ServiceDescriptorProto| { &m.name },
                 |m: &mut ServiceDescriptorProto| { &mut m.name },
             ));
-            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<MethodDescriptorProto>>(
+            fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<MethodDescriptorProto>>(
                 "method",
                 |m: &ServiceDescriptorProto| { &m.method },
                 |m: &mut ServiceDescriptorProto| { &mut m.method },
             ));
-            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ServiceOptions>>(
+            fields.push(crate::reflect::accessor::make_singular_ptr_field_accessor::<_, crate::types::ProtobufTypeMessage<ServiceOptions>>(
                 "options",
                 |m: &ServiceDescriptorProto| { &m.options },
                 |m: &mut ServiceDescriptorProto| { &mut m.options },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ServiceDescriptorProto>(
+            crate::reflect::MessageDescriptor::new_pb_name::<ServiceDescriptorProto>(
                 "ServiceDescriptorProto",
                 fields,
                 file_descriptor_proto()
@@ -3673,12 +3673,12 @@
     }
 
     fn default_instance() -> &'static ServiceDescriptorProto {
-        static instance: ::protobuf::rt::LazyV2<ServiceDescriptorProto> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<ServiceDescriptorProto> = crate::rt::LazyV2::INIT;
         instance.get(ServiceDescriptorProto::new)
     }
 }
 
-impl ::protobuf::Clear for ServiceDescriptorProto {
+impl crate::Clear for ServiceDescriptorProto {
     fn clear(&mut self) {
         self.name.clear();
         self.method.clear();
@@ -3689,13 +3689,13 @@
 
 impl ::std::fmt::Debug for ServiceDescriptorProto {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for ServiceDescriptorProto {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for ServiceDescriptorProto {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -3703,22 +3703,22 @@
 #[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
 pub struct MethodDescriptorProto {
     // message fields
-    name: ::protobuf::SingularField<::std::string::String>,
-    input_type: ::protobuf::SingularField<::std::string::String>,
-    output_type: ::protobuf::SingularField<::std::string::String>,
-    pub options: ::protobuf::SingularPtrField<MethodOptions>,
+    name: crate::SingularField<::std::string::String>,
+    input_type: crate::SingularField<::std::string::String>,
+    output_type: crate::SingularField<::std::string::String>,
+    pub options: crate::SingularPtrField<MethodOptions>,
     client_streaming: ::std::option::Option<bool>,
     server_streaming: ::std::option::Option<bool>,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a MethodDescriptorProto {
     fn default() -> &'a MethodDescriptorProto {
-        <MethodDescriptorProto as ::protobuf::Message>::default_instance()
+        <MethodDescriptorProto as crate::Message>::default_instance()
     }
 }
 
@@ -3746,7 +3746,7 @@
 
     // Param is passed by value, moved
     pub fn set_name(&mut self, v: ::std::string::String) {
-        self.name = ::protobuf::SingularField::some(v);
+        self.name = crate::SingularField::some(v);
     }
 
     // Mutable pointer to the field.
@@ -3782,7 +3782,7 @@
 
     // Param is passed by value, moved
     pub fn set_input_type(&mut self, v: ::std::string::String) {
-        self.input_type = ::protobuf::SingularField::some(v);
+        self.input_type = crate::SingularField::some(v);
     }
 
     // Mutable pointer to the field.
@@ -3818,7 +3818,7 @@
 
     // Param is passed by value, moved
     pub fn set_output_type(&mut self, v: ::std::string::String) {
-        self.output_type = ::protobuf::SingularField::some(v);
+        self.output_type = crate::SingularField::some(v);
     }
 
     // Mutable pointer to the field.
@@ -3839,7 +3839,7 @@
 
 
     pub fn get_options(&self) -> &MethodOptions {
-        self.options.as_ref().unwrap_or_else(|| <MethodOptions as ::protobuf::Message>::default_instance())
+        self.options.as_ref().unwrap_or_else(|| <MethodOptions as crate::Message>::default_instance())
     }
     pub fn clear_options(&mut self) {
         self.options.clear();
@@ -3851,7 +3851,7 @@
 
     // Param is passed by value, moved
     pub fn set_options(&mut self, v: MethodOptions) {
-        self.options = ::protobuf::SingularPtrField::some(v);
+        self.options = crate::SingularPtrField::some(v);
     }
 
     // Mutable pointer to the field.
@@ -3907,7 +3907,7 @@
     }
 }
 
-impl ::protobuf::Message for MethodDescriptorProto {
+impl crate::Message for MethodDescriptorProto {
     fn is_initialized(&self) -> bool {
         for v in &self.options {
             if !v.is_initialized() {
@@ -3917,38 +3917,38 @@
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
         while !is.eof()? {
             let (field_number, wire_type) = is.read_tag_unpack()?;
             match field_number {
                 1 => {
-                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.name)?;
+                    crate::rt::read_singular_string_into(wire_type, is, &mut self.name)?;
                 },
                 2 => {
-                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.input_type)?;
+                    crate::rt::read_singular_string_into(wire_type, is, &mut self.input_type)?;
                 },
                 3 => {
-                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.output_type)?;
+                    crate::rt::read_singular_string_into(wire_type, is, &mut self.output_type)?;
                 },
                 4 => {
-                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.options)?;
+                    crate::rt::read_singular_message_into(wire_type, is, &mut self.options)?;
                 },
                 5 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_bool()?;
                     self.client_streaming = ::std::option::Option::Some(tmp);
                 },
                 6 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_bool()?;
                     self.server_streaming = ::std::option::Option::Some(tmp);
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -3960,17 +3960,17 @@
     fn compute_size(&self) -> u32 {
         let mut my_size = 0;
         if let Some(ref v) = self.name.as_ref() {
-            my_size += ::protobuf::rt::string_size(1, &v);
+            my_size += crate::rt::string_size(1, &v);
         }
         if let Some(ref v) = self.input_type.as_ref() {
-            my_size += ::protobuf::rt::string_size(2, &v);
+            my_size += crate::rt::string_size(2, &v);
         }
         if let Some(ref v) = self.output_type.as_ref() {
-            my_size += ::protobuf::rt::string_size(3, &v);
+            my_size += crate::rt::string_size(3, &v);
         }
         if let Some(ref v) = self.options.as_ref() {
             let len = v.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
         }
         if let Some(v) = self.client_streaming {
             my_size += 2;
@@ -3978,12 +3978,12 @@
         if let Some(v) = self.server_streaming {
             my_size += 2;
         }
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         if let Some(ref v) = self.name.as_ref() {
             os.write_string(1, &v)?;
         }
@@ -3994,7 +3994,7 @@
             os.write_string(3, &v)?;
         }
         if let Some(ref v) = self.options.as_ref() {
-            os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(4, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         }
@@ -4012,11 +4012,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -4030,7 +4030,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -4038,41 +4038,41 @@
         MethodDescriptorProto::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "name",
                 |m: &MethodDescriptorProto| { &m.name },
                 |m: &mut MethodDescriptorProto| { &mut m.name },
             ));
-            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "input_type",
                 |m: &MethodDescriptorProto| { &m.input_type },
                 |m: &mut MethodDescriptorProto| { &mut m.input_type },
             ));
-            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "output_type",
                 |m: &MethodDescriptorProto| { &m.output_type },
                 |m: &mut MethodDescriptorProto| { &mut m.output_type },
             ));
-            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<MethodOptions>>(
+            fields.push(crate::reflect::accessor::make_singular_ptr_field_accessor::<_, crate::types::ProtobufTypeMessage<MethodOptions>>(
                 "options",
                 |m: &MethodDescriptorProto| { &m.options },
                 |m: &mut MethodDescriptorProto| { &mut m.options },
             ));
-            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
+            fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
                 "client_streaming",
                 |m: &MethodDescriptorProto| { &m.client_streaming },
                 |m: &mut MethodDescriptorProto| { &mut m.client_streaming },
             ));
-            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
+            fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
                 "server_streaming",
                 |m: &MethodDescriptorProto| { &m.server_streaming },
                 |m: &mut MethodDescriptorProto| { &mut m.server_streaming },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<MethodDescriptorProto>(
+            crate::reflect::MessageDescriptor::new_pb_name::<MethodDescriptorProto>(
                 "MethodDescriptorProto",
                 fields,
                 file_descriptor_proto()
@@ -4081,12 +4081,12 @@
     }
 
     fn default_instance() -> &'static MethodDescriptorProto {
-        static instance: ::protobuf::rt::LazyV2<MethodDescriptorProto> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<MethodDescriptorProto> = crate::rt::LazyV2::INIT;
         instance.get(MethodDescriptorProto::new)
     }
 }
 
-impl ::protobuf::Clear for MethodDescriptorProto {
+impl crate::Clear for MethodDescriptorProto {
     fn clear(&mut self) {
         self.name.clear();
         self.input_type.clear();
@@ -4100,13 +4100,13 @@
 
 impl ::std::fmt::Debug for MethodDescriptorProto {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for MethodDescriptorProto {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for MethodDescriptorProto {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -4114,31 +4114,31 @@
 #[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
 pub struct FileOptions {
     // message fields
-    java_package: ::protobuf::SingularField<::std::string::String>,
-    java_outer_classname: ::protobuf::SingularField<::std::string::String>,
+    java_package: crate::SingularField<::std::string::String>,
+    java_outer_classname: crate::SingularField<::std::string::String>,
     java_multiple_files: ::std::option::Option<bool>,
     java_generate_equals_and_hash: ::std::option::Option<bool>,
     java_string_check_utf8: ::std::option::Option<bool>,
     optimize_for: ::std::option::Option<FileOptions_OptimizeMode>,
-    go_package: ::protobuf::SingularField<::std::string::String>,
+    go_package: crate::SingularField<::std::string::String>,
     cc_generic_services: ::std::option::Option<bool>,
     java_generic_services: ::std::option::Option<bool>,
     py_generic_services: ::std::option::Option<bool>,
     deprecated: ::std::option::Option<bool>,
     cc_enable_arenas: ::std::option::Option<bool>,
-    objc_class_prefix: ::protobuf::SingularField<::std::string::String>,
-    csharp_namespace: ::protobuf::SingularField<::std::string::String>,
-    pub uninterpreted_option: ::protobuf::RepeatedField<UninterpretedOption>,
+    objc_class_prefix: crate::SingularField<::std::string::String>,
+    csharp_namespace: crate::SingularField<::std::string::String>,
+    pub uninterpreted_option: crate::RepeatedField<UninterpretedOption>,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a FileOptions {
     fn default() -> &'a FileOptions {
-        <FileOptions as ::protobuf::Message>::default_instance()
+        <FileOptions as crate::Message>::default_instance()
     }
 }
 
@@ -4166,7 +4166,7 @@
 
     // Param is passed by value, moved
     pub fn set_java_package(&mut self, v: ::std::string::String) {
-        self.java_package = ::protobuf::SingularField::some(v);
+        self.java_package = crate::SingularField::some(v);
     }
 
     // Mutable pointer to the field.
@@ -4202,7 +4202,7 @@
 
     // Param is passed by value, moved
     pub fn set_java_outer_classname(&mut self, v: ::std::string::String) {
-        self.java_outer_classname = ::protobuf::SingularField::some(v);
+        self.java_outer_classname = crate::SingularField::some(v);
     }
 
     // Mutable pointer to the field.
@@ -4314,7 +4314,7 @@
 
     // Param is passed by value, moved
     pub fn set_go_package(&mut self, v: ::std::string::String) {
-        self.go_package = ::protobuf::SingularField::some(v);
+        self.go_package = crate::SingularField::some(v);
     }
 
     // Mutable pointer to the field.
@@ -4445,7 +4445,7 @@
 
     // Param is passed by value, moved
     pub fn set_objc_class_prefix(&mut self, v: ::std::string::String) {
-        self.objc_class_prefix = ::protobuf::SingularField::some(v);
+        self.objc_class_prefix = crate::SingularField::some(v);
     }
 
     // Mutable pointer to the field.
@@ -4481,7 +4481,7 @@
 
     // Param is passed by value, moved
     pub fn set_csharp_namespace(&mut self, v: ::std::string::String) {
-        self.csharp_namespace = ::protobuf::SingularField::some(v);
+        self.csharp_namespace = crate::SingularField::some(v);
     }
 
     // Mutable pointer to the field.
@@ -4509,22 +4509,22 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_uninterpreted_option(&mut self, v: ::protobuf::RepeatedField<UninterpretedOption>) {
+    pub fn set_uninterpreted_option(&mut self, v: crate::RepeatedField<UninterpretedOption>) {
         self.uninterpreted_option = v;
     }
 
     // Mutable pointer to the field.
-    pub fn mut_uninterpreted_option(&mut self) -> &mut ::protobuf::RepeatedField<UninterpretedOption> {
+    pub fn mut_uninterpreted_option(&mut self) -> &mut crate::RepeatedField<UninterpretedOption> {
         &mut self.uninterpreted_option
     }
 
     // Take field
-    pub fn take_uninterpreted_option(&mut self) -> ::protobuf::RepeatedField<UninterpretedOption> {
-        ::std::mem::replace(&mut self.uninterpreted_option, ::protobuf::RepeatedField::new())
+    pub fn take_uninterpreted_option(&mut self) -> crate::RepeatedField<UninterpretedOption> {
+        ::std::mem::replace(&mut self.uninterpreted_option, crate::RepeatedField::new())
     }
 }
 
-impl ::protobuf::Message for FileOptions {
+impl crate::Message for FileOptions {
     fn is_initialized(&self) -> bool {
         for v in &self.uninterpreted_option {
             if !v.is_initialized() {
@@ -4534,89 +4534,89 @@
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
         while !is.eof()? {
             let (field_number, wire_type) = is.read_tag_unpack()?;
             match field_number {
                 1 => {
-                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.java_package)?;
+                    crate::rt::read_singular_string_into(wire_type, is, &mut self.java_package)?;
                 },
                 8 => {
-                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.java_outer_classname)?;
+                    crate::rt::read_singular_string_into(wire_type, is, &mut self.java_outer_classname)?;
                 },
                 10 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_bool()?;
                     self.java_multiple_files = ::std::option::Option::Some(tmp);
                 },
                 20 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_bool()?;
                     self.java_generate_equals_and_hash = ::std::option::Option::Some(tmp);
                 },
                 27 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_bool()?;
                     self.java_string_check_utf8 = ::std::option::Option::Some(tmp);
                 },
                 9 => {
-                    ::protobuf::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.optimize_for, 9, &mut self.unknown_fields)?
+                    crate::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.optimize_for, 9, &mut self.unknown_fields)?
                 },
                 11 => {
-                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.go_package)?;
+                    crate::rt::read_singular_string_into(wire_type, is, &mut self.go_package)?;
                 },
                 16 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_bool()?;
                     self.cc_generic_services = ::std::option::Option::Some(tmp);
                 },
                 17 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_bool()?;
                     self.java_generic_services = ::std::option::Option::Some(tmp);
                 },
                 18 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_bool()?;
                     self.py_generic_services = ::std::option::Option::Some(tmp);
                 },
                 23 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_bool()?;
                     self.deprecated = ::std::option::Option::Some(tmp);
                 },
                 31 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_bool()?;
                     self.cc_enable_arenas = ::std::option::Option::Some(tmp);
                 },
                 36 => {
-                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.objc_class_prefix)?;
+                    crate::rt::read_singular_string_into(wire_type, is, &mut self.objc_class_prefix)?;
                 },
                 37 => {
-                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.csharp_namespace)?;
+                    crate::rt::read_singular_string_into(wire_type, is, &mut self.csharp_namespace)?;
                 },
                 999 => {
-                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.uninterpreted_option)?;
+                    crate::rt::read_repeated_message_into(wire_type, is, &mut self.uninterpreted_option)?;
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -4628,10 +4628,10 @@
     fn compute_size(&self) -> u32 {
         let mut my_size = 0;
         if let Some(ref v) = self.java_package.as_ref() {
-            my_size += ::protobuf::rt::string_size(1, &v);
+            my_size += crate::rt::string_size(1, &v);
         }
         if let Some(ref v) = self.java_outer_classname.as_ref() {
-            my_size += ::protobuf::rt::string_size(8, &v);
+            my_size += crate::rt::string_size(8, &v);
         }
         if let Some(v) = self.java_multiple_files {
             my_size += 2;
@@ -4643,10 +4643,10 @@
             my_size += 3;
         }
         if let Some(v) = self.optimize_for {
-            my_size += ::protobuf::rt::enum_size(9, v);
+            my_size += crate::rt::enum_size(9, v);
         }
         if let Some(ref v) = self.go_package.as_ref() {
-            my_size += ::protobuf::rt::string_size(11, &v);
+            my_size += crate::rt::string_size(11, &v);
         }
         if let Some(v) = self.cc_generic_services {
             my_size += 3;
@@ -4664,21 +4664,21 @@
             my_size += 3;
         }
         if let Some(ref v) = self.objc_class_prefix.as_ref() {
-            my_size += ::protobuf::rt::string_size(36, &v);
+            my_size += crate::rt::string_size(36, &v);
         }
         if let Some(ref v) = self.csharp_namespace.as_ref() {
-            my_size += ::protobuf::rt::string_size(37, &v);
+            my_size += crate::rt::string_size(37, &v);
         }
         for value in &self.uninterpreted_option {
             let len = value.compute_size();
-            my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 2 + crate::rt::compute_raw_varint32_size(len) + len;
         };
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         if let Some(ref v) = self.java_package.as_ref() {
             os.write_string(1, &v)?;
         }
@@ -4695,7 +4695,7 @@
             os.write_bool(27, v)?;
         }
         if let Some(v) = self.optimize_for {
-            os.write_enum(9, ::protobuf::ProtobufEnum::value(&v))?;
+            os.write_enum(9, crate::ProtobufEnum::value(&v))?;
         }
         if let Some(ref v) = self.go_package.as_ref() {
             os.write_string(11, &v)?;
@@ -4722,7 +4722,7 @@
             os.write_string(37, &v)?;
         }
         for v in &self.uninterpreted_option {
-            os.write_tag(999, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(999, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         };
@@ -4734,11 +4734,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -4752,7 +4752,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -4760,86 +4760,86 @@
         FileOptions::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "java_package",
                 |m: &FileOptions| { &m.java_package },
                 |m: &mut FileOptions| { &mut m.java_package },
             ));
-            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "java_outer_classname",
                 |m: &FileOptions| { &m.java_outer_classname },
                 |m: &mut FileOptions| { &mut m.java_outer_classname },
             ));
-            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
+            fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
                 "java_multiple_files",
                 |m: &FileOptions| { &m.java_multiple_files },
                 |m: &mut FileOptions| { &mut m.java_multiple_files },
             ));
-            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
+            fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
                 "java_generate_equals_and_hash",
                 |m: &FileOptions| { &m.java_generate_equals_and_hash },
                 |m: &mut FileOptions| { &mut m.java_generate_equals_and_hash },
             ));
-            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
+            fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
                 "java_string_check_utf8",
                 |m: &FileOptions| { &m.java_string_check_utf8 },
                 |m: &mut FileOptions| { &mut m.java_string_check_utf8 },
             ));
-            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<FileOptions_OptimizeMode>>(
+            fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeEnum<FileOptions_OptimizeMode>>(
                 "optimize_for",
                 |m: &FileOptions| { &m.optimize_for },
                 |m: &mut FileOptions| { &mut m.optimize_for },
             ));
-            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "go_package",
                 |m: &FileOptions| { &m.go_package },
                 |m: &mut FileOptions| { &mut m.go_package },
             ));
-            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
+            fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
                 "cc_generic_services",
                 |m: &FileOptions| { &m.cc_generic_services },
                 |m: &mut FileOptions| { &mut m.cc_generic_services },
             ));
-            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
+            fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
                 "java_generic_services",
                 |m: &FileOptions| { &m.java_generic_services },
                 |m: &mut FileOptions| { &mut m.java_generic_services },
             ));
-            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
+            fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
                 "py_generic_services",
                 |m: &FileOptions| { &m.py_generic_services },
                 |m: &mut FileOptions| { &mut m.py_generic_services },
             ));
-            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
+            fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
                 "deprecated",
                 |m: &FileOptions| { &m.deprecated },
                 |m: &mut FileOptions| { &mut m.deprecated },
             ));
-            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
+            fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
                 "cc_enable_arenas",
                 |m: &FileOptions| { &m.cc_enable_arenas },
                 |m: &mut FileOptions| { &mut m.cc_enable_arenas },
             ));
-            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "objc_class_prefix",
                 |m: &FileOptions| { &m.objc_class_prefix },
                 |m: &mut FileOptions| { &mut m.objc_class_prefix },
             ));
-            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "csharp_namespace",
                 |m: &FileOptions| { &m.csharp_namespace },
                 |m: &mut FileOptions| { &mut m.csharp_namespace },
             ));
-            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<UninterpretedOption>>(
+            fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<UninterpretedOption>>(
                 "uninterpreted_option",
                 |m: &FileOptions| { &m.uninterpreted_option },
                 |m: &mut FileOptions| { &mut m.uninterpreted_option },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<FileOptions>(
+            crate::reflect::MessageDescriptor::new_pb_name::<FileOptions>(
                 "FileOptions",
                 fields,
                 file_descriptor_proto()
@@ -4848,12 +4848,12 @@
     }
 
     fn default_instance() -> &'static FileOptions {
-        static instance: ::protobuf::rt::LazyV2<FileOptions> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<FileOptions> = crate::rt::LazyV2::INIT;
         instance.get(FileOptions::new)
     }
 }
 
-impl ::protobuf::Clear for FileOptions {
+impl crate::Clear for FileOptions {
     fn clear(&mut self) {
         self.java_package.clear();
         self.java_outer_classname.clear();
@@ -4876,13 +4876,13 @@
 
 impl ::std::fmt::Debug for FileOptions {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for FileOptions {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for FileOptions {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -4894,7 +4894,7 @@
     LITE_RUNTIME = 3,
 }
 
-impl ::protobuf::ProtobufEnum for FileOptions_OptimizeMode {
+impl crate::ProtobufEnum for FileOptions_OptimizeMode {
     fn value(&self) -> i32 {
         *self as i32
     }
@@ -4917,10 +4917,10 @@
         values
     }
 
-    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn enum_descriptor_static() -> &'static crate::reflect::EnumDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::EnumDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
-            ::protobuf::reflect::EnumDescriptor::new_pb_name::<FileOptions_OptimizeMode>("FileOptions.OptimizeMode", file_descriptor_proto())
+            crate::reflect::EnumDescriptor::new_pb_name::<FileOptions_OptimizeMode>("FileOptions.OptimizeMode", file_descriptor_proto())
         })
     }
 }
@@ -4935,9 +4935,9 @@
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for FileOptions_OptimizeMode {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
+impl crate::reflect::ProtobufValue for FileOptions_OptimizeMode {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Enum(crate::ProtobufEnum::descriptor(self))
     }
 }
 
@@ -4949,17 +4949,17 @@
     no_standard_descriptor_accessor: ::std::option::Option<bool>,
     deprecated: ::std::option::Option<bool>,
     map_entry: ::std::option::Option<bool>,
-    pub uninterpreted_option: ::protobuf::RepeatedField<UninterpretedOption>,
+    pub uninterpreted_option: crate::RepeatedField<UninterpretedOption>,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a MessageOptions {
     fn default() -> &'a MessageOptions {
-        <MessageOptions as ::protobuf::Message>::default_instance()
+        <MessageOptions as crate::Message>::default_instance()
     }
 }
 
@@ -5055,22 +5055,22 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_uninterpreted_option(&mut self, v: ::protobuf::RepeatedField<UninterpretedOption>) {
+    pub fn set_uninterpreted_option(&mut self, v: crate::RepeatedField<UninterpretedOption>) {
         self.uninterpreted_option = v;
     }
 
     // Mutable pointer to the field.
-    pub fn mut_uninterpreted_option(&mut self) -> &mut ::protobuf::RepeatedField<UninterpretedOption> {
+    pub fn mut_uninterpreted_option(&mut self) -> &mut crate::RepeatedField<UninterpretedOption> {
         &mut self.uninterpreted_option
     }
 
     // Take field
-    pub fn take_uninterpreted_option(&mut self) -> ::protobuf::RepeatedField<UninterpretedOption> {
-        ::std::mem::replace(&mut self.uninterpreted_option, ::protobuf::RepeatedField::new())
+    pub fn take_uninterpreted_option(&mut self) -> crate::RepeatedField<UninterpretedOption> {
+        ::std::mem::replace(&mut self.uninterpreted_option, crate::RepeatedField::new())
     }
 }
 
-impl ::protobuf::Message for MessageOptions {
+impl crate::Message for MessageOptions {
     fn is_initialized(&self) -> bool {
         for v in &self.uninterpreted_option {
             if !v.is_initialized() {
@@ -5080,43 +5080,43 @@
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::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));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_bool()?;
                     self.message_set_wire_format = ::std::option::Option::Some(tmp);
                 },
                 2 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_bool()?;
                     self.no_standard_descriptor_accessor = ::std::option::Option::Some(tmp);
                 },
                 3 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_bool()?;
                     self.deprecated = ::std::option::Option::Some(tmp);
                 },
                 7 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_bool()?;
                     self.map_entry = ::std::option::Option::Some(tmp);
                 },
                 999 => {
-                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.uninterpreted_option)?;
+                    crate::rt::read_repeated_message_into(wire_type, is, &mut self.uninterpreted_option)?;
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -5141,14 +5141,14 @@
         }
         for value in &self.uninterpreted_option {
             let len = value.compute_size();
-            my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 2 + crate::rt::compute_raw_varint32_size(len) + len;
         };
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         if let Some(v) = self.message_set_wire_format {
             os.write_bool(1, v)?;
         }
@@ -5162,7 +5162,7 @@
             os.write_bool(7, v)?;
         }
         for v in &self.uninterpreted_option {
-            os.write_tag(999, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(999, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         };
@@ -5174,11 +5174,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -5192,7 +5192,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -5200,36 +5200,36 @@
         MessageOptions::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
+            fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
                 "message_set_wire_format",
                 |m: &MessageOptions| { &m.message_set_wire_format },
                 |m: &mut MessageOptions| { &mut m.message_set_wire_format },
             ));
-            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
+            fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
                 "no_standard_descriptor_accessor",
                 |m: &MessageOptions| { &m.no_standard_descriptor_accessor },
                 |m: &mut MessageOptions| { &mut m.no_standard_descriptor_accessor },
             ));
-            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
+            fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
                 "deprecated",
                 |m: &MessageOptions| { &m.deprecated },
                 |m: &mut MessageOptions| { &mut m.deprecated },
             ));
-            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
+            fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
                 "map_entry",
                 |m: &MessageOptions| { &m.map_entry },
                 |m: &mut MessageOptions| { &mut m.map_entry },
             ));
-            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<UninterpretedOption>>(
+            fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<UninterpretedOption>>(
                 "uninterpreted_option",
                 |m: &MessageOptions| { &m.uninterpreted_option },
                 |m: &mut MessageOptions| { &mut m.uninterpreted_option },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<MessageOptions>(
+            crate::reflect::MessageDescriptor::new_pb_name::<MessageOptions>(
                 "MessageOptions",
                 fields,
                 file_descriptor_proto()
@@ -5238,12 +5238,12 @@
     }
 
     fn default_instance() -> &'static MessageOptions {
-        static instance: ::protobuf::rt::LazyV2<MessageOptions> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<MessageOptions> = crate::rt::LazyV2::INIT;
         instance.get(MessageOptions::new)
     }
 }
 
-impl ::protobuf::Clear for MessageOptions {
+impl crate::Clear for MessageOptions {
     fn clear(&mut self) {
         self.message_set_wire_format = ::std::option::Option::None;
         self.no_standard_descriptor_accessor = ::std::option::Option::None;
@@ -5256,13 +5256,13 @@
 
 impl ::std::fmt::Debug for MessageOptions {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for MessageOptions {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for MessageOptions {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -5276,17 +5276,17 @@
     lazy: ::std::option::Option<bool>,
     deprecated: ::std::option::Option<bool>,
     weak: ::std::option::Option<bool>,
-    pub uninterpreted_option: ::protobuf::RepeatedField<UninterpretedOption>,
+    pub uninterpreted_option: crate::RepeatedField<UninterpretedOption>,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a FieldOptions {
     fn default() -> &'a FieldOptions {
-        <FieldOptions as ::protobuf::Message>::default_instance()
+        <FieldOptions as crate::Message>::default_instance()
     }
 }
 
@@ -5420,22 +5420,22 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_uninterpreted_option(&mut self, v: ::protobuf::RepeatedField<UninterpretedOption>) {
+    pub fn set_uninterpreted_option(&mut self, v: crate::RepeatedField<UninterpretedOption>) {
         self.uninterpreted_option = v;
     }
 
     // Mutable pointer to the field.
-    pub fn mut_uninterpreted_option(&mut self) -> &mut ::protobuf::RepeatedField<UninterpretedOption> {
+    pub fn mut_uninterpreted_option(&mut self) -> &mut crate::RepeatedField<UninterpretedOption> {
         &mut self.uninterpreted_option
     }
 
     // Take field
-    pub fn take_uninterpreted_option(&mut self) -> ::protobuf::RepeatedField<UninterpretedOption> {
-        ::std::mem::replace(&mut self.uninterpreted_option, ::protobuf::RepeatedField::new())
+    pub fn take_uninterpreted_option(&mut self) -> crate::RepeatedField<UninterpretedOption> {
+        ::std::mem::replace(&mut self.uninterpreted_option, crate::RepeatedField::new())
     }
 }
 
-impl ::protobuf::Message for FieldOptions {
+impl crate::Message for FieldOptions {
     fn is_initialized(&self) -> bool {
         for v in &self.uninterpreted_option {
             if !v.is_initialized() {
@@ -5445,49 +5445,49 @@
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
         while !is.eof()? {
             let (field_number, wire_type) = is.read_tag_unpack()?;
             match field_number {
                 1 => {
-                    ::protobuf::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.ctype, 1, &mut self.unknown_fields)?
+                    crate::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.ctype, 1, &mut self.unknown_fields)?
                 },
                 2 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_bool()?;
                     self.packed = ::std::option::Option::Some(tmp);
                 },
                 6 => {
-                    ::protobuf::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.jstype, 6, &mut self.unknown_fields)?
+                    crate::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.jstype, 6, &mut self.unknown_fields)?
                 },
                 5 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_bool()?;
                     self.lazy = ::std::option::Option::Some(tmp);
                 },
                 3 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_bool()?;
                     self.deprecated = ::std::option::Option::Some(tmp);
                 },
                 10 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_bool()?;
                     self.weak = ::std::option::Option::Some(tmp);
                 },
                 999 => {
-                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.uninterpreted_option)?;
+                    crate::rt::read_repeated_message_into(wire_type, is, &mut self.uninterpreted_option)?;
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -5499,13 +5499,13 @@
     fn compute_size(&self) -> u32 {
         let mut my_size = 0;
         if let Some(v) = self.ctype {
-            my_size += ::protobuf::rt::enum_size(1, v);
+            my_size += crate::rt::enum_size(1, v);
         }
         if let Some(v) = self.packed {
             my_size += 2;
         }
         if let Some(v) = self.jstype {
-            my_size += ::protobuf::rt::enum_size(6, v);
+            my_size += crate::rt::enum_size(6, v);
         }
         if let Some(v) = self.lazy {
             my_size += 2;
@@ -5518,22 +5518,22 @@
         }
         for value in &self.uninterpreted_option {
             let len = value.compute_size();
-            my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 2 + crate::rt::compute_raw_varint32_size(len) + len;
         };
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         if let Some(v) = self.ctype {
-            os.write_enum(1, ::protobuf::ProtobufEnum::value(&v))?;
+            os.write_enum(1, crate::ProtobufEnum::value(&v))?;
         }
         if let Some(v) = self.packed {
             os.write_bool(2, v)?;
         }
         if let Some(v) = self.jstype {
-            os.write_enum(6, ::protobuf::ProtobufEnum::value(&v))?;
+            os.write_enum(6, crate::ProtobufEnum::value(&v))?;
         }
         if let Some(v) = self.lazy {
             os.write_bool(5, v)?;
@@ -5545,7 +5545,7 @@
             os.write_bool(10, v)?;
         }
         for v in &self.uninterpreted_option {
-            os.write_tag(999, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(999, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         };
@@ -5557,11 +5557,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -5575,7 +5575,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -5583,46 +5583,46 @@
         FieldOptions::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<FieldOptions_CType>>(
+            fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeEnum<FieldOptions_CType>>(
                 "ctype",
                 |m: &FieldOptions| { &m.ctype },
                 |m: &mut FieldOptions| { &mut m.ctype },
             ));
-            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
+            fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
                 "packed",
                 |m: &FieldOptions| { &m.packed },
                 |m: &mut FieldOptions| { &mut m.packed },
             ));
-            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum<FieldOptions_JSType>>(
+            fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeEnum<FieldOptions_JSType>>(
                 "jstype",
                 |m: &FieldOptions| { &m.jstype },
                 |m: &mut FieldOptions| { &mut m.jstype },
             ));
-            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
+            fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
                 "lazy",
                 |m: &FieldOptions| { &m.lazy },
                 |m: &mut FieldOptions| { &mut m.lazy },
             ));
-            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
+            fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
                 "deprecated",
                 |m: &FieldOptions| { &m.deprecated },
                 |m: &mut FieldOptions| { &mut m.deprecated },
             ));
-            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
+            fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
                 "weak",
                 |m: &FieldOptions| { &m.weak },
                 |m: &mut FieldOptions| { &mut m.weak },
             ));
-            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<UninterpretedOption>>(
+            fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<UninterpretedOption>>(
                 "uninterpreted_option",
                 |m: &FieldOptions| { &m.uninterpreted_option },
                 |m: &mut FieldOptions| { &mut m.uninterpreted_option },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<FieldOptions>(
+            crate::reflect::MessageDescriptor::new_pb_name::<FieldOptions>(
                 "FieldOptions",
                 fields,
                 file_descriptor_proto()
@@ -5631,12 +5631,12 @@
     }
 
     fn default_instance() -> &'static FieldOptions {
-        static instance: ::protobuf::rt::LazyV2<FieldOptions> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<FieldOptions> = crate::rt::LazyV2::INIT;
         instance.get(FieldOptions::new)
     }
 }
 
-impl ::protobuf::Clear for FieldOptions {
+impl crate::Clear for FieldOptions {
     fn clear(&mut self) {
         self.ctype = ::std::option::Option::None;
         self.packed = ::std::option::Option::None;
@@ -5651,13 +5651,13 @@
 
 impl ::std::fmt::Debug for FieldOptions {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for FieldOptions {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for FieldOptions {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -5669,7 +5669,7 @@
     STRING_PIECE = 2,
 }
 
-impl ::protobuf::ProtobufEnum for FieldOptions_CType {
+impl crate::ProtobufEnum for FieldOptions_CType {
     fn value(&self) -> i32 {
         *self as i32
     }
@@ -5692,10 +5692,10 @@
         values
     }
 
-    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn enum_descriptor_static() -> &'static crate::reflect::EnumDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::EnumDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
-            ::protobuf::reflect::EnumDescriptor::new_pb_name::<FieldOptions_CType>("FieldOptions.CType", file_descriptor_proto())
+            crate::reflect::EnumDescriptor::new_pb_name::<FieldOptions_CType>("FieldOptions.CType", file_descriptor_proto())
         })
     }
 }
@@ -5709,9 +5709,9 @@
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for FieldOptions_CType {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
+impl crate::reflect::ProtobufValue for FieldOptions_CType {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Enum(crate::ProtobufEnum::descriptor(self))
     }
 }
 
@@ -5723,7 +5723,7 @@
     JS_NUMBER = 2,
 }
 
-impl ::protobuf::ProtobufEnum for FieldOptions_JSType {
+impl crate::ProtobufEnum for FieldOptions_JSType {
     fn value(&self) -> i32 {
         *self as i32
     }
@@ -5746,10 +5746,10 @@
         values
     }
 
-    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn enum_descriptor_static() -> &'static crate::reflect::EnumDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::EnumDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
-            ::protobuf::reflect::EnumDescriptor::new_pb_name::<FieldOptions_JSType>("FieldOptions.JSType", file_descriptor_proto())
+            crate::reflect::EnumDescriptor::new_pb_name::<FieldOptions_JSType>("FieldOptions.JSType", file_descriptor_proto())
         })
     }
 }
@@ -5763,9 +5763,9 @@
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for FieldOptions_JSType {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
+impl crate::reflect::ProtobufValue for FieldOptions_JSType {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Enum(crate::ProtobufEnum::descriptor(self))
     }
 }
 
@@ -5773,17 +5773,17 @@
 #[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
 pub struct OneofOptions {
     // message fields
-    pub uninterpreted_option: ::protobuf::RepeatedField<UninterpretedOption>,
+    pub uninterpreted_option: crate::RepeatedField<UninterpretedOption>,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a OneofOptions {
     fn default() -> &'a OneofOptions {
-        <OneofOptions as ::protobuf::Message>::default_instance()
+        <OneofOptions as crate::Message>::default_instance()
     }
 }
 
@@ -5803,22 +5803,22 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_uninterpreted_option(&mut self, v: ::protobuf::RepeatedField<UninterpretedOption>) {
+    pub fn set_uninterpreted_option(&mut self, v: crate::RepeatedField<UninterpretedOption>) {
         self.uninterpreted_option = v;
     }
 
     // Mutable pointer to the field.
-    pub fn mut_uninterpreted_option(&mut self) -> &mut ::protobuf::RepeatedField<UninterpretedOption> {
+    pub fn mut_uninterpreted_option(&mut self) -> &mut crate::RepeatedField<UninterpretedOption> {
         &mut self.uninterpreted_option
     }
 
     // Take field
-    pub fn take_uninterpreted_option(&mut self) -> ::protobuf::RepeatedField<UninterpretedOption> {
-        ::std::mem::replace(&mut self.uninterpreted_option, ::protobuf::RepeatedField::new())
+    pub fn take_uninterpreted_option(&mut self) -> crate::RepeatedField<UninterpretedOption> {
+        ::std::mem::replace(&mut self.uninterpreted_option, crate::RepeatedField::new())
     }
 }
 
-impl ::protobuf::Message for OneofOptions {
+impl crate::Message for OneofOptions {
     fn is_initialized(&self) -> bool {
         for v in &self.uninterpreted_option {
             if !v.is_initialized() {
@@ -5828,15 +5828,15 @@
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
         while !is.eof()? {
             let (field_number, wire_type) = is.read_tag_unpack()?;
             match field_number {
                 999 => {
-                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.uninterpreted_option)?;
+                    crate::rt::read_repeated_message_into(wire_type, is, &mut self.uninterpreted_option)?;
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -5849,16 +5849,16 @@
         let mut my_size = 0;
         for value in &self.uninterpreted_option {
             let len = value.compute_size();
-            my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 2 + crate::rt::compute_raw_varint32_size(len) + len;
         };
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         for v in &self.uninterpreted_option {
-            os.write_tag(999, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(999, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         };
@@ -5870,11 +5870,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -5888,7 +5888,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -5896,16 +5896,16 @@
         OneofOptions::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<UninterpretedOption>>(
+            fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<UninterpretedOption>>(
                 "uninterpreted_option",
                 |m: &OneofOptions| { &m.uninterpreted_option },
                 |m: &mut OneofOptions| { &mut m.uninterpreted_option },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<OneofOptions>(
+            crate::reflect::MessageDescriptor::new_pb_name::<OneofOptions>(
                 "OneofOptions",
                 fields,
                 file_descriptor_proto()
@@ -5914,12 +5914,12 @@
     }
 
     fn default_instance() -> &'static OneofOptions {
-        static instance: ::protobuf::rt::LazyV2<OneofOptions> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<OneofOptions> = crate::rt::LazyV2::INIT;
         instance.get(OneofOptions::new)
     }
 }
 
-impl ::protobuf::Clear for OneofOptions {
+impl crate::Clear for OneofOptions {
     fn clear(&mut self) {
         self.uninterpreted_option.clear();
         self.unknown_fields.clear();
@@ -5928,13 +5928,13 @@
 
 impl ::std::fmt::Debug for OneofOptions {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for OneofOptions {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for OneofOptions {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -5944,17 +5944,17 @@
     // message fields
     allow_alias: ::std::option::Option<bool>,
     deprecated: ::std::option::Option<bool>,
-    pub uninterpreted_option: ::protobuf::RepeatedField<UninterpretedOption>,
+    pub uninterpreted_option: crate::RepeatedField<UninterpretedOption>,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a EnumOptions {
     fn default() -> &'a EnumOptions {
-        <EnumOptions as ::protobuf::Message>::default_instance()
+        <EnumOptions as crate::Message>::default_instance()
     }
 }
 
@@ -6012,22 +6012,22 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_uninterpreted_option(&mut self, v: ::protobuf::RepeatedField<UninterpretedOption>) {
+    pub fn set_uninterpreted_option(&mut self, v: crate::RepeatedField<UninterpretedOption>) {
         self.uninterpreted_option = v;
     }
 
     // Mutable pointer to the field.
-    pub fn mut_uninterpreted_option(&mut self) -> &mut ::protobuf::RepeatedField<UninterpretedOption> {
+    pub fn mut_uninterpreted_option(&mut self) -> &mut crate::RepeatedField<UninterpretedOption> {
         &mut self.uninterpreted_option
     }
 
     // Take field
-    pub fn take_uninterpreted_option(&mut self) -> ::protobuf::RepeatedField<UninterpretedOption> {
-        ::std::mem::replace(&mut self.uninterpreted_option, ::protobuf::RepeatedField::new())
+    pub fn take_uninterpreted_option(&mut self) -> crate::RepeatedField<UninterpretedOption> {
+        ::std::mem::replace(&mut self.uninterpreted_option, crate::RepeatedField::new())
     }
 }
 
-impl ::protobuf::Message for EnumOptions {
+impl crate::Message for EnumOptions {
     fn is_initialized(&self) -> bool {
         for v in &self.uninterpreted_option {
             if !v.is_initialized() {
@@ -6037,29 +6037,29 @@
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
         while !is.eof()? {
             let (field_number, wire_type) = is.read_tag_unpack()?;
             match field_number {
                 2 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_bool()?;
                     self.allow_alias = ::std::option::Option::Some(tmp);
                 },
                 3 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_bool()?;
                     self.deprecated = ::std::option::Option::Some(tmp);
                 },
                 999 => {
-                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.uninterpreted_option)?;
+                    crate::rt::read_repeated_message_into(wire_type, is, &mut self.uninterpreted_option)?;
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -6078,14 +6078,14 @@
         }
         for value in &self.uninterpreted_option {
             let len = value.compute_size();
-            my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 2 + crate::rt::compute_raw_varint32_size(len) + len;
         };
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         if let Some(v) = self.allow_alias {
             os.write_bool(2, v)?;
         }
@@ -6093,7 +6093,7 @@
             os.write_bool(3, v)?;
         }
         for v in &self.uninterpreted_option {
-            os.write_tag(999, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(999, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         };
@@ -6105,11 +6105,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -6123,7 +6123,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -6131,26 +6131,26 @@
         EnumOptions::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
+            fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
                 "allow_alias",
                 |m: &EnumOptions| { &m.allow_alias },
                 |m: &mut EnumOptions| { &mut m.allow_alias },
             ));
-            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
+            fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
                 "deprecated",
                 |m: &EnumOptions| { &m.deprecated },
                 |m: &mut EnumOptions| { &mut m.deprecated },
             ));
-            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<UninterpretedOption>>(
+            fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<UninterpretedOption>>(
                 "uninterpreted_option",
                 |m: &EnumOptions| { &m.uninterpreted_option },
                 |m: &mut EnumOptions| { &mut m.uninterpreted_option },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<EnumOptions>(
+            crate::reflect::MessageDescriptor::new_pb_name::<EnumOptions>(
                 "EnumOptions",
                 fields,
                 file_descriptor_proto()
@@ -6159,12 +6159,12 @@
     }
 
     fn default_instance() -> &'static EnumOptions {
-        static instance: ::protobuf::rt::LazyV2<EnumOptions> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<EnumOptions> = crate::rt::LazyV2::INIT;
         instance.get(EnumOptions::new)
     }
 }
 
-impl ::protobuf::Clear for EnumOptions {
+impl crate::Clear for EnumOptions {
     fn clear(&mut self) {
         self.allow_alias = ::std::option::Option::None;
         self.deprecated = ::std::option::Option::None;
@@ -6175,13 +6175,13 @@
 
 impl ::std::fmt::Debug for EnumOptions {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for EnumOptions {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for EnumOptions {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -6190,17 +6190,17 @@
 pub struct EnumValueOptions {
     // message fields
     deprecated: ::std::option::Option<bool>,
-    pub uninterpreted_option: ::protobuf::RepeatedField<UninterpretedOption>,
+    pub uninterpreted_option: crate::RepeatedField<UninterpretedOption>,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a EnumValueOptions {
     fn default() -> &'a EnumValueOptions {
-        <EnumValueOptions as ::protobuf::Message>::default_instance()
+        <EnumValueOptions as crate::Message>::default_instance()
     }
 }
 
@@ -6239,22 +6239,22 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_uninterpreted_option(&mut self, v: ::protobuf::RepeatedField<UninterpretedOption>) {
+    pub fn set_uninterpreted_option(&mut self, v: crate::RepeatedField<UninterpretedOption>) {
         self.uninterpreted_option = v;
     }
 
     // Mutable pointer to the field.
-    pub fn mut_uninterpreted_option(&mut self) -> &mut ::protobuf::RepeatedField<UninterpretedOption> {
+    pub fn mut_uninterpreted_option(&mut self) -> &mut crate::RepeatedField<UninterpretedOption> {
         &mut self.uninterpreted_option
     }
 
     // Take field
-    pub fn take_uninterpreted_option(&mut self) -> ::protobuf::RepeatedField<UninterpretedOption> {
-        ::std::mem::replace(&mut self.uninterpreted_option, ::protobuf::RepeatedField::new())
+    pub fn take_uninterpreted_option(&mut self) -> crate::RepeatedField<UninterpretedOption> {
+        ::std::mem::replace(&mut self.uninterpreted_option, crate::RepeatedField::new())
     }
 }
 
-impl ::protobuf::Message for EnumValueOptions {
+impl crate::Message for EnumValueOptions {
     fn is_initialized(&self) -> bool {
         for v in &self.uninterpreted_option {
             if !v.is_initialized() {
@@ -6264,22 +6264,22 @@
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::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));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_bool()?;
                     self.deprecated = ::std::option::Option::Some(tmp);
                 },
                 999 => {
-                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.uninterpreted_option)?;
+                    crate::rt::read_repeated_message_into(wire_type, is, &mut self.uninterpreted_option)?;
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -6295,19 +6295,19 @@
         }
         for value in &self.uninterpreted_option {
             let len = value.compute_size();
-            my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 2 + crate::rt::compute_raw_varint32_size(len) + len;
         };
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         if let Some(v) = self.deprecated {
             os.write_bool(1, v)?;
         }
         for v in &self.uninterpreted_option {
-            os.write_tag(999, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(999, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         };
@@ -6319,11 +6319,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -6337,7 +6337,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -6345,21 +6345,21 @@
         EnumValueOptions::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
+            fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
                 "deprecated",
                 |m: &EnumValueOptions| { &m.deprecated },
                 |m: &mut EnumValueOptions| { &mut m.deprecated },
             ));
-            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<UninterpretedOption>>(
+            fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<UninterpretedOption>>(
                 "uninterpreted_option",
                 |m: &EnumValueOptions| { &m.uninterpreted_option },
                 |m: &mut EnumValueOptions| { &mut m.uninterpreted_option },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<EnumValueOptions>(
+            crate::reflect::MessageDescriptor::new_pb_name::<EnumValueOptions>(
                 "EnumValueOptions",
                 fields,
                 file_descriptor_proto()
@@ -6368,12 +6368,12 @@
     }
 
     fn default_instance() -> &'static EnumValueOptions {
-        static instance: ::protobuf::rt::LazyV2<EnumValueOptions> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<EnumValueOptions> = crate::rt::LazyV2::INIT;
         instance.get(EnumValueOptions::new)
     }
 }
 
-impl ::protobuf::Clear for EnumValueOptions {
+impl crate::Clear for EnumValueOptions {
     fn clear(&mut self) {
         self.deprecated = ::std::option::Option::None;
         self.uninterpreted_option.clear();
@@ -6383,13 +6383,13 @@
 
 impl ::std::fmt::Debug for EnumValueOptions {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for EnumValueOptions {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for EnumValueOptions {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -6398,17 +6398,17 @@
 pub struct ServiceOptions {
     // message fields
     deprecated: ::std::option::Option<bool>,
-    pub uninterpreted_option: ::protobuf::RepeatedField<UninterpretedOption>,
+    pub uninterpreted_option: crate::RepeatedField<UninterpretedOption>,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a ServiceOptions {
     fn default() -> &'a ServiceOptions {
-        <ServiceOptions as ::protobuf::Message>::default_instance()
+        <ServiceOptions as crate::Message>::default_instance()
     }
 }
 
@@ -6447,22 +6447,22 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_uninterpreted_option(&mut self, v: ::protobuf::RepeatedField<UninterpretedOption>) {
+    pub fn set_uninterpreted_option(&mut self, v: crate::RepeatedField<UninterpretedOption>) {
         self.uninterpreted_option = v;
     }
 
     // Mutable pointer to the field.
-    pub fn mut_uninterpreted_option(&mut self) -> &mut ::protobuf::RepeatedField<UninterpretedOption> {
+    pub fn mut_uninterpreted_option(&mut self) -> &mut crate::RepeatedField<UninterpretedOption> {
         &mut self.uninterpreted_option
     }
 
     // Take field
-    pub fn take_uninterpreted_option(&mut self) -> ::protobuf::RepeatedField<UninterpretedOption> {
-        ::std::mem::replace(&mut self.uninterpreted_option, ::protobuf::RepeatedField::new())
+    pub fn take_uninterpreted_option(&mut self) -> crate::RepeatedField<UninterpretedOption> {
+        ::std::mem::replace(&mut self.uninterpreted_option, crate::RepeatedField::new())
     }
 }
 
-impl ::protobuf::Message for ServiceOptions {
+impl crate::Message for ServiceOptions {
     fn is_initialized(&self) -> bool {
         for v in &self.uninterpreted_option {
             if !v.is_initialized() {
@@ -6472,22 +6472,22 @@
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
         while !is.eof()? {
             let (field_number, wire_type) = is.read_tag_unpack()?;
             match field_number {
                 33 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_bool()?;
                     self.deprecated = ::std::option::Option::Some(tmp);
                 },
                 999 => {
-                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.uninterpreted_option)?;
+                    crate::rt::read_repeated_message_into(wire_type, is, &mut self.uninterpreted_option)?;
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -6503,19 +6503,19 @@
         }
         for value in &self.uninterpreted_option {
             let len = value.compute_size();
-            my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 2 + crate::rt::compute_raw_varint32_size(len) + len;
         };
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         if let Some(v) = self.deprecated {
             os.write_bool(33, v)?;
         }
         for v in &self.uninterpreted_option {
-            os.write_tag(999, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(999, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         };
@@ -6527,11 +6527,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -6545,7 +6545,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -6553,21 +6553,21 @@
         ServiceOptions::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
+            fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
                 "deprecated",
                 |m: &ServiceOptions| { &m.deprecated },
                 |m: &mut ServiceOptions| { &mut m.deprecated },
             ));
-            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<UninterpretedOption>>(
+            fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<UninterpretedOption>>(
                 "uninterpreted_option",
                 |m: &ServiceOptions| { &m.uninterpreted_option },
                 |m: &mut ServiceOptions| { &mut m.uninterpreted_option },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ServiceOptions>(
+            crate::reflect::MessageDescriptor::new_pb_name::<ServiceOptions>(
                 "ServiceOptions",
                 fields,
                 file_descriptor_proto()
@@ -6576,12 +6576,12 @@
     }
 
     fn default_instance() -> &'static ServiceOptions {
-        static instance: ::protobuf::rt::LazyV2<ServiceOptions> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<ServiceOptions> = crate::rt::LazyV2::INIT;
         instance.get(ServiceOptions::new)
     }
 }
 
-impl ::protobuf::Clear for ServiceOptions {
+impl crate::Clear for ServiceOptions {
     fn clear(&mut self) {
         self.deprecated = ::std::option::Option::None;
         self.uninterpreted_option.clear();
@@ -6591,13 +6591,13 @@
 
 impl ::std::fmt::Debug for ServiceOptions {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for ServiceOptions {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for ServiceOptions {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -6606,17 +6606,17 @@
 pub struct MethodOptions {
     // message fields
     deprecated: ::std::option::Option<bool>,
-    pub uninterpreted_option: ::protobuf::RepeatedField<UninterpretedOption>,
+    pub uninterpreted_option: crate::RepeatedField<UninterpretedOption>,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a MethodOptions {
     fn default() -> &'a MethodOptions {
-        <MethodOptions as ::protobuf::Message>::default_instance()
+        <MethodOptions as crate::Message>::default_instance()
     }
 }
 
@@ -6655,22 +6655,22 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_uninterpreted_option(&mut self, v: ::protobuf::RepeatedField<UninterpretedOption>) {
+    pub fn set_uninterpreted_option(&mut self, v: crate::RepeatedField<UninterpretedOption>) {
         self.uninterpreted_option = v;
     }
 
     // Mutable pointer to the field.
-    pub fn mut_uninterpreted_option(&mut self) -> &mut ::protobuf::RepeatedField<UninterpretedOption> {
+    pub fn mut_uninterpreted_option(&mut self) -> &mut crate::RepeatedField<UninterpretedOption> {
         &mut self.uninterpreted_option
     }
 
     // Take field
-    pub fn take_uninterpreted_option(&mut self) -> ::protobuf::RepeatedField<UninterpretedOption> {
-        ::std::mem::replace(&mut self.uninterpreted_option, ::protobuf::RepeatedField::new())
+    pub fn take_uninterpreted_option(&mut self) -> crate::RepeatedField<UninterpretedOption> {
+        ::std::mem::replace(&mut self.uninterpreted_option, crate::RepeatedField::new())
     }
 }
 
-impl ::protobuf::Message for MethodOptions {
+impl crate::Message for MethodOptions {
     fn is_initialized(&self) -> bool {
         for v in &self.uninterpreted_option {
             if !v.is_initialized() {
@@ -6680,22 +6680,22 @@
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
         while !is.eof()? {
             let (field_number, wire_type) = is.read_tag_unpack()?;
             match field_number {
                 33 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_bool()?;
                     self.deprecated = ::std::option::Option::Some(tmp);
                 },
                 999 => {
-                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.uninterpreted_option)?;
+                    crate::rt::read_repeated_message_into(wire_type, is, &mut self.uninterpreted_option)?;
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -6711,19 +6711,19 @@
         }
         for value in &self.uninterpreted_option {
             let len = value.compute_size();
-            my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 2 + crate::rt::compute_raw_varint32_size(len) + len;
         };
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         if let Some(v) = self.deprecated {
             os.write_bool(33, v)?;
         }
         for v in &self.uninterpreted_option {
-            os.write_tag(999, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(999, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         };
@@ -6735,11 +6735,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -6753,7 +6753,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -6761,21 +6761,21 @@
         MethodOptions::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
+            fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
                 "deprecated",
                 |m: &MethodOptions| { &m.deprecated },
                 |m: &mut MethodOptions| { &mut m.deprecated },
             ));
-            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<UninterpretedOption>>(
+            fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<UninterpretedOption>>(
                 "uninterpreted_option",
                 |m: &MethodOptions| { &m.uninterpreted_option },
                 |m: &mut MethodOptions| { &mut m.uninterpreted_option },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<MethodOptions>(
+            crate::reflect::MessageDescriptor::new_pb_name::<MethodOptions>(
                 "MethodOptions",
                 fields,
                 file_descriptor_proto()
@@ -6784,12 +6784,12 @@
     }
 
     fn default_instance() -> &'static MethodOptions {
-        static instance: ::protobuf::rt::LazyV2<MethodOptions> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<MethodOptions> = crate::rt::LazyV2::INIT;
         instance.get(MethodOptions::new)
     }
 }
 
-impl ::protobuf::Clear for MethodOptions {
+impl crate::Clear for MethodOptions {
     fn clear(&mut self) {
         self.deprecated = ::std::option::Option::None;
         self.uninterpreted_option.clear();
@@ -6799,13 +6799,13 @@
 
 impl ::std::fmt::Debug for MethodOptions {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for MethodOptions {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for MethodOptions {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -6813,23 +6813,23 @@
 #[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
 pub struct UninterpretedOption {
     // message fields
-    pub name: ::protobuf::RepeatedField<UninterpretedOption_NamePart>,
-    identifier_value: ::protobuf::SingularField<::std::string::String>,
+    pub name: crate::RepeatedField<UninterpretedOption_NamePart>,
+    identifier_value: crate::SingularField<::std::string::String>,
     positive_int_value: ::std::option::Option<u64>,
     negative_int_value: ::std::option::Option<i64>,
     double_value: ::std::option::Option<f64>,
-    string_value: ::protobuf::SingularField<::std::vec::Vec<u8>>,
-    aggregate_value: ::protobuf::SingularField<::std::string::String>,
+    string_value: crate::SingularField<::std::vec::Vec<u8>>,
+    aggregate_value: crate::SingularField<::std::string::String>,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a UninterpretedOption {
     fn default() -> &'a UninterpretedOption {
-        <UninterpretedOption as ::protobuf::Message>::default_instance()
+        <UninterpretedOption as crate::Message>::default_instance()
     }
 }
 
@@ -6849,18 +6849,18 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_name(&mut self, v: ::protobuf::RepeatedField<UninterpretedOption_NamePart>) {
+    pub fn set_name(&mut self, v: crate::RepeatedField<UninterpretedOption_NamePart>) {
         self.name = v;
     }
 
     // Mutable pointer to the field.
-    pub fn mut_name(&mut self) -> &mut ::protobuf::RepeatedField<UninterpretedOption_NamePart> {
+    pub fn mut_name(&mut self) -> &mut crate::RepeatedField<UninterpretedOption_NamePart> {
         &mut self.name
     }
 
     // Take field
-    pub fn take_name(&mut self) -> ::protobuf::RepeatedField<UninterpretedOption_NamePart> {
-        ::std::mem::replace(&mut self.name, ::protobuf::RepeatedField::new())
+    pub fn take_name(&mut self) -> crate::RepeatedField<UninterpretedOption_NamePart> {
+        ::std::mem::replace(&mut self.name, crate::RepeatedField::new())
     }
 
     // optional string identifier_value = 3;
@@ -6882,7 +6882,7 @@
 
     // Param is passed by value, moved
     pub fn set_identifier_value(&mut self, v: ::std::string::String) {
-        self.identifier_value = ::protobuf::SingularField::some(v);
+        self.identifier_value = crate::SingularField::some(v);
     }
 
     // Mutable pointer to the field.
@@ -6975,7 +6975,7 @@
 
     // Param is passed by value, moved
     pub fn set_string_value(&mut self, v: ::std::vec::Vec<u8>) {
-        self.string_value = ::protobuf::SingularField::some(v);
+        self.string_value = crate::SingularField::some(v);
     }
 
     // Mutable pointer to the field.
@@ -7011,7 +7011,7 @@
 
     // Param is passed by value, moved
     pub fn set_aggregate_value(&mut self, v: ::std::string::String) {
-        self.aggregate_value = ::protobuf::SingularField::some(v);
+        self.aggregate_value = crate::SingularField::some(v);
     }
 
     // Mutable pointer to the field.
@@ -7029,7 +7029,7 @@
     }
 }
 
-impl ::protobuf::Message for UninterpretedOption {
+impl crate::Message for UninterpretedOption {
     fn is_initialized(&self) -> bool {
         for v in &self.name {
             if !v.is_initialized() {
@@ -7039,45 +7039,45 @@
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
         while !is.eof()? {
             let (field_number, wire_type) = is.read_tag_unpack()?;
             match field_number {
                 2 => {
-                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.name)?;
+                    crate::rt::read_repeated_message_into(wire_type, is, &mut self.name)?;
                 },
                 3 => {
-                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.identifier_value)?;
+                    crate::rt::read_singular_string_into(wire_type, is, &mut self.identifier_value)?;
                 },
                 4 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_uint64()?;
                     self.positive_int_value = ::std::option::Option::Some(tmp);
                 },
                 5 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_int64()?;
                     self.negative_int_value = ::std::option::Option::Some(tmp);
                 },
                 6 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeFixed64 {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_double()?;
                     self.double_value = ::std::option::Option::Some(tmp);
                 },
                 7 => {
-                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.string_value)?;
+                    crate::rt::read_singular_bytes_into(wire_type, is, &mut self.string_value)?;
                 },
                 8 => {
-                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.aggregate_value)?;
+                    crate::rt::read_singular_string_into(wire_type, is, &mut self.aggregate_value)?;
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -7090,34 +7090,34 @@
         let mut my_size = 0;
         for value in &self.name {
             let len = value.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
         };
         if let Some(ref v) = self.identifier_value.as_ref() {
-            my_size += ::protobuf::rt::string_size(3, &v);
+            my_size += crate::rt::string_size(3, &v);
         }
         if let Some(v) = self.positive_int_value {
-            my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint);
+            my_size += crate::rt::value_size(4, v, crate::wire_format::WireTypeVarint);
         }
         if let Some(v) = self.negative_int_value {
-            my_size += ::protobuf::rt::value_size(5, v, ::protobuf::wire_format::WireTypeVarint);
+            my_size += crate::rt::value_size(5, v, crate::wire_format::WireTypeVarint);
         }
         if let Some(v) = self.double_value {
             my_size += 9;
         }
         if let Some(ref v) = self.string_value.as_ref() {
-            my_size += ::protobuf::rt::bytes_size(7, &v);
+            my_size += crate::rt::bytes_size(7, &v);
         }
         if let Some(ref v) = self.aggregate_value.as_ref() {
-            my_size += ::protobuf::rt::string_size(8, &v);
+            my_size += crate::rt::string_size(8, &v);
         }
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         for v in &self.name {
-            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(2, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         };
@@ -7147,11 +7147,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -7165,7 +7165,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -7173,46 +7173,46 @@
         UninterpretedOption::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<UninterpretedOption_NamePart>>(
+            fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<UninterpretedOption_NamePart>>(
                 "name",
                 |m: &UninterpretedOption| { &m.name },
                 |m: &mut UninterpretedOption| { &mut m.name },
             ));
-            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "identifier_value",
                 |m: &UninterpretedOption| { &m.identifier_value },
                 |m: &mut UninterpretedOption| { &mut m.identifier_value },
             ));
-            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
+            fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeUint64>(
                 "positive_int_value",
                 |m: &UninterpretedOption| { &m.positive_int_value },
                 |m: &mut UninterpretedOption| { &mut m.positive_int_value },
             ));
-            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
+            fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeInt64>(
                 "negative_int_value",
                 |m: &UninterpretedOption| { &m.negative_int_value },
                 |m: &mut UninterpretedOption| { &mut m.negative_int_value },
             ));
-            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
+            fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeDouble>(
                 "double_value",
                 |m: &UninterpretedOption| { &m.double_value },
                 |m: &mut UninterpretedOption| { &mut m.double_value },
             ));
-            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
+            fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeBytes>(
                 "string_value",
                 |m: &UninterpretedOption| { &m.string_value },
                 |m: &mut UninterpretedOption| { &mut m.string_value },
             ));
-            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "aggregate_value",
                 |m: &UninterpretedOption| { &m.aggregate_value },
                 |m: &mut UninterpretedOption| { &mut m.aggregate_value },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<UninterpretedOption>(
+            crate::reflect::MessageDescriptor::new_pb_name::<UninterpretedOption>(
                 "UninterpretedOption",
                 fields,
                 file_descriptor_proto()
@@ -7221,12 +7221,12 @@
     }
 
     fn default_instance() -> &'static UninterpretedOption {
-        static instance: ::protobuf::rt::LazyV2<UninterpretedOption> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<UninterpretedOption> = crate::rt::LazyV2::INIT;
         instance.get(UninterpretedOption::new)
     }
 }
 
-impl ::protobuf::Clear for UninterpretedOption {
+impl crate::Clear for UninterpretedOption {
     fn clear(&mut self) {
         self.name.clear();
         self.identifier_value.clear();
@@ -7241,13 +7241,13 @@
 
 impl ::std::fmt::Debug for UninterpretedOption {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for UninterpretedOption {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for UninterpretedOption {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -7255,18 +7255,18 @@
 #[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
 pub struct UninterpretedOption_NamePart {
     // message fields
-    name_part: ::protobuf::SingularField<::std::string::String>,
+    name_part: crate::SingularField<::std::string::String>,
     is_extension: ::std::option::Option<bool>,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a UninterpretedOption_NamePart {
     fn default() -> &'a UninterpretedOption_NamePart {
-        <UninterpretedOption_NamePart as ::protobuf::Message>::default_instance()
+        <UninterpretedOption_NamePart as crate::Message>::default_instance()
     }
 }
 
@@ -7294,7 +7294,7 @@
 
     // Param is passed by value, moved
     pub fn set_name_part(&mut self, v: ::std::string::String) {
-        self.name_part = ::protobuf::SingularField::some(v);
+        self.name_part = crate::SingularField::some(v);
     }
 
     // Mutable pointer to the field.
@@ -7331,7 +7331,7 @@
     }
 }
 
-impl ::protobuf::Message for UninterpretedOption_NamePart {
+impl crate::Message for UninterpretedOption_NamePart {
     fn is_initialized(&self) -> bool {
         if self.name_part.is_none() {
             return false;
@@ -7342,22 +7342,22 @@
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
         while !is.eof()? {
             let (field_number, wire_type) = is.read_tag_unpack()?;
             match field_number {
                 1 => {
-                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.name_part)?;
+                    crate::rt::read_singular_string_into(wire_type, is, &mut self.name_part)?;
                 },
                 2 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_bool()?;
                     self.is_extension = ::std::option::Option::Some(tmp);
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -7369,17 +7369,17 @@
     fn compute_size(&self) -> u32 {
         let mut my_size = 0;
         if let Some(ref v) = self.name_part.as_ref() {
-            my_size += ::protobuf::rt::string_size(1, &v);
+            my_size += crate::rt::string_size(1, &v);
         }
         if let Some(v) = self.is_extension {
             my_size += 2;
         }
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         if let Some(ref v) = self.name_part.as_ref() {
             os.write_string(1, &v)?;
         }
@@ -7394,11 +7394,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -7412,7 +7412,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -7420,21 +7420,21 @@
         UninterpretedOption_NamePart::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "name_part",
                 |m: &UninterpretedOption_NamePart| { &m.name_part },
                 |m: &mut UninterpretedOption_NamePart| { &mut m.name_part },
             ));
-            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
+            fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeBool>(
                 "is_extension",
                 |m: &UninterpretedOption_NamePart| { &m.is_extension },
                 |m: &mut UninterpretedOption_NamePart| { &mut m.is_extension },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<UninterpretedOption_NamePart>(
+            crate::reflect::MessageDescriptor::new_pb_name::<UninterpretedOption_NamePart>(
                 "UninterpretedOption.NamePart",
                 fields,
                 file_descriptor_proto()
@@ -7443,12 +7443,12 @@
     }
 
     fn default_instance() -> &'static UninterpretedOption_NamePart {
-        static instance: ::protobuf::rt::LazyV2<UninterpretedOption_NamePart> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<UninterpretedOption_NamePart> = crate::rt::LazyV2::INIT;
         instance.get(UninterpretedOption_NamePart::new)
     }
 }
 
-impl ::protobuf::Clear for UninterpretedOption_NamePart {
+impl crate::Clear for UninterpretedOption_NamePart {
     fn clear(&mut self) {
         self.name_part.clear();
         self.is_extension = ::std::option::Option::None;
@@ -7458,13 +7458,13 @@
 
 impl ::std::fmt::Debug for UninterpretedOption_NamePart {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for UninterpretedOption_NamePart {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for UninterpretedOption_NamePart {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -7472,17 +7472,17 @@
 #[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
 pub struct SourceCodeInfo {
     // message fields
-    pub location: ::protobuf::RepeatedField<SourceCodeInfo_Location>,
+    pub location: crate::RepeatedField<SourceCodeInfo_Location>,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a SourceCodeInfo {
     fn default() -> &'a SourceCodeInfo {
-        <SourceCodeInfo as ::protobuf::Message>::default_instance()
+        <SourceCodeInfo as crate::Message>::default_instance()
     }
 }
 
@@ -7502,22 +7502,22 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_location(&mut self, v: ::protobuf::RepeatedField<SourceCodeInfo_Location>) {
+    pub fn set_location(&mut self, v: crate::RepeatedField<SourceCodeInfo_Location>) {
         self.location = v;
     }
 
     // Mutable pointer to the field.
-    pub fn mut_location(&mut self) -> &mut ::protobuf::RepeatedField<SourceCodeInfo_Location> {
+    pub fn mut_location(&mut self) -> &mut crate::RepeatedField<SourceCodeInfo_Location> {
         &mut self.location
     }
 
     // Take field
-    pub fn take_location(&mut self) -> ::protobuf::RepeatedField<SourceCodeInfo_Location> {
-        ::std::mem::replace(&mut self.location, ::protobuf::RepeatedField::new())
+    pub fn take_location(&mut self) -> crate::RepeatedField<SourceCodeInfo_Location> {
+        ::std::mem::replace(&mut self.location, crate::RepeatedField::new())
     }
 }
 
-impl ::protobuf::Message for SourceCodeInfo {
+impl crate::Message for SourceCodeInfo {
     fn is_initialized(&self) -> bool {
         for v in &self.location {
             if !v.is_initialized() {
@@ -7527,15 +7527,15 @@
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
         while !is.eof()? {
             let (field_number, wire_type) = is.read_tag_unpack()?;
             match field_number {
                 1 => {
-                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.location)?;
+                    crate::rt::read_repeated_message_into(wire_type, is, &mut self.location)?;
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -7548,16 +7548,16 @@
         let mut my_size = 0;
         for value in &self.location {
             let len = value.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
         };
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         for v in &self.location {
-            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(1, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         };
@@ -7569,11 +7569,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -7587,7 +7587,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -7595,16 +7595,16 @@
         SourceCodeInfo::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<SourceCodeInfo_Location>>(
+            fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<SourceCodeInfo_Location>>(
                 "location",
                 |m: &SourceCodeInfo| { &m.location },
                 |m: &mut SourceCodeInfo| { &mut m.location },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<SourceCodeInfo>(
+            crate::reflect::MessageDescriptor::new_pb_name::<SourceCodeInfo>(
                 "SourceCodeInfo",
                 fields,
                 file_descriptor_proto()
@@ -7613,12 +7613,12 @@
     }
 
     fn default_instance() -> &'static SourceCodeInfo {
-        static instance: ::protobuf::rt::LazyV2<SourceCodeInfo> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<SourceCodeInfo> = crate::rt::LazyV2::INIT;
         instance.get(SourceCodeInfo::new)
     }
 }
 
-impl ::protobuf::Clear for SourceCodeInfo {
+impl crate::Clear for SourceCodeInfo {
     fn clear(&mut self) {
         self.location.clear();
         self.unknown_fields.clear();
@@ -7627,13 +7627,13 @@
 
 impl ::std::fmt::Debug for SourceCodeInfo {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for SourceCodeInfo {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for SourceCodeInfo {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -7643,19 +7643,19 @@
     // message fields
     pub path: ::std::vec::Vec<i32>,
     pub span: ::std::vec::Vec<i32>,
-    leading_comments: ::protobuf::SingularField<::std::string::String>,
-    trailing_comments: ::protobuf::SingularField<::std::string::String>,
-    pub leading_detached_comments: ::protobuf::RepeatedField<::std::string::String>,
+    leading_comments: crate::SingularField<::std::string::String>,
+    trailing_comments: crate::SingularField<::std::string::String>,
+    pub leading_detached_comments: crate::RepeatedField<::std::string::String>,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a SourceCodeInfo_Location {
     fn default() -> &'a SourceCodeInfo_Location {
-        <SourceCodeInfo_Location as ::protobuf::Message>::default_instance()
+        <SourceCodeInfo_Location as crate::Message>::default_instance()
     }
 }
 
@@ -7733,7 +7733,7 @@
 
     // Param is passed by value, moved
     pub fn set_leading_comments(&mut self, v: ::std::string::String) {
-        self.leading_comments = ::protobuf::SingularField::some(v);
+        self.leading_comments = crate::SingularField::some(v);
     }
 
     // Mutable pointer to the field.
@@ -7769,7 +7769,7 @@
 
     // Param is passed by value, moved
     pub fn set_trailing_comments(&mut self, v: ::std::string::String) {
-        self.trailing_comments = ::protobuf::SingularField::some(v);
+        self.trailing_comments = crate::SingularField::some(v);
     }
 
     // Mutable pointer to the field.
@@ -7797,47 +7797,47 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_leading_detached_comments(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
+    pub fn set_leading_detached_comments(&mut self, v: crate::RepeatedField<::std::string::String>) {
         self.leading_detached_comments = v;
     }
 
     // Mutable pointer to the field.
-    pub fn mut_leading_detached_comments(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
+    pub fn mut_leading_detached_comments(&mut self) -> &mut crate::RepeatedField<::std::string::String> {
         &mut self.leading_detached_comments
     }
 
     // Take field
-    pub fn take_leading_detached_comments(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
-        ::std::mem::replace(&mut self.leading_detached_comments, ::protobuf::RepeatedField::new())
+    pub fn take_leading_detached_comments(&mut self) -> crate::RepeatedField<::std::string::String> {
+        ::std::mem::replace(&mut self.leading_detached_comments, crate::RepeatedField::new())
     }
 }
 
-impl ::protobuf::Message for SourceCodeInfo_Location {
+impl crate::Message for SourceCodeInfo_Location {
     fn is_initialized(&self) -> bool {
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
         while !is.eof()? {
             let (field_number, wire_type) = is.read_tag_unpack()?;
             match field_number {
                 1 => {
-                    ::protobuf::rt::read_repeated_int32_into(wire_type, is, &mut self.path)?;
+                    crate::rt::read_repeated_int32_into(wire_type, is, &mut self.path)?;
                 },
                 2 => {
-                    ::protobuf::rt::read_repeated_int32_into(wire_type, is, &mut self.span)?;
+                    crate::rt::read_repeated_int32_into(wire_type, is, &mut self.span)?;
                 },
                 3 => {
-                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.leading_comments)?;
+                    crate::rt::read_singular_string_into(wire_type, is, &mut self.leading_comments)?;
                 },
                 4 => {
-                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.trailing_comments)?;
+                    crate::rt::read_singular_string_into(wire_type, is, &mut self.trailing_comments)?;
                 },
                 6 => {
-                    ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.leading_detached_comments)?;
+                    crate::rt::read_repeated_string_into(wire_type, is, &mut self.leading_detached_comments)?;
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -7849,38 +7849,38 @@
     fn compute_size(&self) -> u32 {
         let mut my_size = 0;
         if !self.path.is_empty() {
-            my_size += ::protobuf::rt::vec_packed_varint_size(1, &self.path);
+            my_size += crate::rt::vec_packed_varint_size(1, &self.path);
         }
         if !self.span.is_empty() {
-            my_size += ::protobuf::rt::vec_packed_varint_size(2, &self.span);
+            my_size += crate::rt::vec_packed_varint_size(2, &self.span);
         }
         if let Some(ref v) = self.leading_comments.as_ref() {
-            my_size += ::protobuf::rt::string_size(3, &v);
+            my_size += crate::rt::string_size(3, &v);
         }
         if let Some(ref v) = self.trailing_comments.as_ref() {
-            my_size += ::protobuf::rt::string_size(4, &v);
+            my_size += crate::rt::string_size(4, &v);
         }
         for value in &self.leading_detached_comments {
-            my_size += ::protobuf::rt::string_size(6, &value);
+            my_size += crate::rt::string_size(6, &value);
         };
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         if !self.path.is_empty() {
-            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(1, crate::wire_format::WireTypeLengthDelimited)?;
             // TODO: Data size is computed again, it should be cached
-            os.write_raw_varint32(::protobuf::rt::vec_packed_varint_data_size(&self.path))?;
+            os.write_raw_varint32(crate::rt::vec_packed_varint_data_size(&self.path))?;
             for v in &self.path {
                 os.write_int32_no_tag(*v)?;
             };
         }
         if !self.span.is_empty() {
-            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(2, crate::wire_format::WireTypeLengthDelimited)?;
             // TODO: Data size is computed again, it should be cached
-            os.write_raw_varint32(::protobuf::rt::vec_packed_varint_data_size(&self.span))?;
+            os.write_raw_varint32(crate::rt::vec_packed_varint_data_size(&self.span))?;
             for v in &self.span {
                 os.write_int32_no_tag(*v)?;
             };
@@ -7902,11 +7902,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -7920,7 +7920,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -7928,36 +7928,36 @@
         SourceCodeInfo_Location::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
+            fields.push(crate::reflect::accessor::make_vec_accessor::<_, crate::types::ProtobufTypeInt32>(
                 "path",
                 |m: &SourceCodeInfo_Location| { &m.path },
                 |m: &mut SourceCodeInfo_Location| { &mut m.path },
             ));
-            fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
+            fields.push(crate::reflect::accessor::make_vec_accessor::<_, crate::types::ProtobufTypeInt32>(
                 "span",
                 |m: &SourceCodeInfo_Location| { &m.span },
                 |m: &mut SourceCodeInfo_Location| { &mut m.span },
             ));
-            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "leading_comments",
                 |m: &SourceCodeInfo_Location| { &m.leading_comments },
                 |m: &mut SourceCodeInfo_Location| { &mut m.leading_comments },
             ));
-            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "trailing_comments",
                 |m: &SourceCodeInfo_Location| { &m.trailing_comments },
                 |m: &mut SourceCodeInfo_Location| { &mut m.trailing_comments },
             ));
-            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "leading_detached_comments",
                 |m: &SourceCodeInfo_Location| { &m.leading_detached_comments },
                 |m: &mut SourceCodeInfo_Location| { &mut m.leading_detached_comments },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<SourceCodeInfo_Location>(
+            crate::reflect::MessageDescriptor::new_pb_name::<SourceCodeInfo_Location>(
                 "SourceCodeInfo.Location",
                 fields,
                 file_descriptor_proto()
@@ -7966,12 +7966,12 @@
     }
 
     fn default_instance() -> &'static SourceCodeInfo_Location {
-        static instance: ::protobuf::rt::LazyV2<SourceCodeInfo_Location> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<SourceCodeInfo_Location> = crate::rt::LazyV2::INIT;
         instance.get(SourceCodeInfo_Location::new)
     }
 }
 
-impl ::protobuf::Clear for SourceCodeInfo_Location {
+impl crate::Clear for SourceCodeInfo_Location {
     fn clear(&mut self) {
         self.path.clear();
         self.span.clear();
@@ -7984,13 +7984,13 @@
 
 impl ::std::fmt::Debug for SourceCodeInfo_Location {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for SourceCodeInfo_Location {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for SourceCodeInfo_Location {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -7998,17 +7998,17 @@
 #[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
 pub struct GeneratedCodeInfo {
     // message fields
-    pub annotation: ::protobuf::RepeatedField<GeneratedCodeInfo_Annotation>,
+    pub annotation: crate::RepeatedField<GeneratedCodeInfo_Annotation>,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a GeneratedCodeInfo {
     fn default() -> &'a GeneratedCodeInfo {
-        <GeneratedCodeInfo as ::protobuf::Message>::default_instance()
+        <GeneratedCodeInfo as crate::Message>::default_instance()
     }
 }
 
@@ -8028,22 +8028,22 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_annotation(&mut self, v: ::protobuf::RepeatedField<GeneratedCodeInfo_Annotation>) {
+    pub fn set_annotation(&mut self, v: crate::RepeatedField<GeneratedCodeInfo_Annotation>) {
         self.annotation = v;
     }
 
     // Mutable pointer to the field.
-    pub fn mut_annotation(&mut self) -> &mut ::protobuf::RepeatedField<GeneratedCodeInfo_Annotation> {
+    pub fn mut_annotation(&mut self) -> &mut crate::RepeatedField<GeneratedCodeInfo_Annotation> {
         &mut self.annotation
     }
 
     // Take field
-    pub fn take_annotation(&mut self) -> ::protobuf::RepeatedField<GeneratedCodeInfo_Annotation> {
-        ::std::mem::replace(&mut self.annotation, ::protobuf::RepeatedField::new())
+    pub fn take_annotation(&mut self) -> crate::RepeatedField<GeneratedCodeInfo_Annotation> {
+        ::std::mem::replace(&mut self.annotation, crate::RepeatedField::new())
     }
 }
 
-impl ::protobuf::Message for GeneratedCodeInfo {
+impl crate::Message for GeneratedCodeInfo {
     fn is_initialized(&self) -> bool {
         for v in &self.annotation {
             if !v.is_initialized() {
@@ -8053,15 +8053,15 @@
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
         while !is.eof()? {
             let (field_number, wire_type) = is.read_tag_unpack()?;
             match field_number {
                 1 => {
-                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.annotation)?;
+                    crate::rt::read_repeated_message_into(wire_type, is, &mut self.annotation)?;
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -8074,16 +8074,16 @@
         let mut my_size = 0;
         for value in &self.annotation {
             let len = value.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
         };
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         for v in &self.annotation {
-            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(1, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         };
@@ -8095,11 +8095,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -8113,7 +8113,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -8121,16 +8121,16 @@
         GeneratedCodeInfo::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<GeneratedCodeInfo_Annotation>>(
+            fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<GeneratedCodeInfo_Annotation>>(
                 "annotation",
                 |m: &GeneratedCodeInfo| { &m.annotation },
                 |m: &mut GeneratedCodeInfo| { &mut m.annotation },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<GeneratedCodeInfo>(
+            crate::reflect::MessageDescriptor::new_pb_name::<GeneratedCodeInfo>(
                 "GeneratedCodeInfo",
                 fields,
                 file_descriptor_proto()
@@ -8139,12 +8139,12 @@
     }
 
     fn default_instance() -> &'static GeneratedCodeInfo {
-        static instance: ::protobuf::rt::LazyV2<GeneratedCodeInfo> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<GeneratedCodeInfo> = crate::rt::LazyV2::INIT;
         instance.get(GeneratedCodeInfo::new)
     }
 }
 
-impl ::protobuf::Clear for GeneratedCodeInfo {
+impl crate::Clear for GeneratedCodeInfo {
     fn clear(&mut self) {
         self.annotation.clear();
         self.unknown_fields.clear();
@@ -8153,13 +8153,13 @@
 
 impl ::std::fmt::Debug for GeneratedCodeInfo {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for GeneratedCodeInfo {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for GeneratedCodeInfo {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -8168,19 +8168,19 @@
 pub struct GeneratedCodeInfo_Annotation {
     // message fields
     pub path: ::std::vec::Vec<i32>,
-    source_file: ::protobuf::SingularField<::std::string::String>,
+    source_file: crate::SingularField<::std::string::String>,
     begin: ::std::option::Option<i32>,
     end: ::std::option::Option<i32>,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a GeneratedCodeInfo_Annotation {
     fn default() -> &'a GeneratedCodeInfo_Annotation {
-        <GeneratedCodeInfo_Annotation as ::protobuf::Message>::default_instance()
+        <GeneratedCodeInfo_Annotation as crate::Message>::default_instance()
     }
 }
 
@@ -8233,7 +8233,7 @@
 
     // Param is passed by value, moved
     pub fn set_source_file(&mut self, v: ::std::string::String) {
-        self.source_file = ::protobuf::SingularField::some(v);
+        self.source_file = crate::SingularField::some(v);
     }
 
     // Mutable pointer to the field.
@@ -8289,37 +8289,37 @@
     }
 }
 
-impl ::protobuf::Message for GeneratedCodeInfo_Annotation {
+impl crate::Message for GeneratedCodeInfo_Annotation {
     fn is_initialized(&self) -> bool {
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
         while !is.eof()? {
             let (field_number, wire_type) = is.read_tag_unpack()?;
             match field_number {
                 1 => {
-                    ::protobuf::rt::read_repeated_int32_into(wire_type, is, &mut self.path)?;
+                    crate::rt::read_repeated_int32_into(wire_type, is, &mut self.path)?;
                 },
                 2 => {
-                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.source_file)?;
+                    crate::rt::read_singular_string_into(wire_type, is, &mut self.source_file)?;
                 },
                 3 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_int32()?;
                     self.begin = ::std::option::Option::Some(tmp);
                 },
                 4 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_int32()?;
                     self.end = ::std::option::Option::Some(tmp);
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -8331,27 +8331,27 @@
     fn compute_size(&self) -> u32 {
         let mut my_size = 0;
         if !self.path.is_empty() {
-            my_size += ::protobuf::rt::vec_packed_varint_size(1, &self.path);
+            my_size += crate::rt::vec_packed_varint_size(1, &self.path);
         }
         if let Some(ref v) = self.source_file.as_ref() {
-            my_size += ::protobuf::rt::string_size(2, &v);
+            my_size += crate::rt::string_size(2, &v);
         }
         if let Some(v) = self.begin {
-            my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
+            my_size += crate::rt::value_size(3, v, crate::wire_format::WireTypeVarint);
         }
         if let Some(v) = self.end {
-            my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint);
+            my_size += crate::rt::value_size(4, v, crate::wire_format::WireTypeVarint);
         }
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         if !self.path.is_empty() {
-            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(1, crate::wire_format::WireTypeLengthDelimited)?;
             // TODO: Data size is computed again, it should be cached
-            os.write_raw_varint32(::protobuf::rt::vec_packed_varint_data_size(&self.path))?;
+            os.write_raw_varint32(crate::rt::vec_packed_varint_data_size(&self.path))?;
             for v in &self.path {
                 os.write_int32_no_tag(*v)?;
             };
@@ -8373,11 +8373,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -8391,7 +8391,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -8399,31 +8399,31 @@
         GeneratedCodeInfo_Annotation::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_vec_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
+            fields.push(crate::reflect::accessor::make_vec_accessor::<_, crate::types::ProtobufTypeInt32>(
                 "path",
                 |m: &GeneratedCodeInfo_Annotation| { &m.path },
                 |m: &mut GeneratedCodeInfo_Annotation| { &mut m.path },
             ));
-            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "source_file",
                 |m: &GeneratedCodeInfo_Annotation| { &m.source_file },
                 |m: &mut GeneratedCodeInfo_Annotation| { &mut m.source_file },
             ));
-            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
+            fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeInt32>(
                 "begin",
                 |m: &GeneratedCodeInfo_Annotation| { &m.begin },
                 |m: &mut GeneratedCodeInfo_Annotation| { &mut m.begin },
             ));
-            fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
+            fields.push(crate::reflect::accessor::make_option_accessor::<_, crate::types::ProtobufTypeInt32>(
                 "end",
                 |m: &GeneratedCodeInfo_Annotation| { &m.end },
                 |m: &mut GeneratedCodeInfo_Annotation| { &mut m.end },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<GeneratedCodeInfo_Annotation>(
+            crate::reflect::MessageDescriptor::new_pb_name::<GeneratedCodeInfo_Annotation>(
                 "GeneratedCodeInfo.Annotation",
                 fields,
                 file_descriptor_proto()
@@ -8432,12 +8432,12 @@
     }
 
     fn default_instance() -> &'static GeneratedCodeInfo_Annotation {
-        static instance: ::protobuf::rt::LazyV2<GeneratedCodeInfo_Annotation> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<GeneratedCodeInfo_Annotation> = crate::rt::LazyV2::INIT;
         instance.get(GeneratedCodeInfo_Annotation::new)
     }
 }
 
-impl ::protobuf::Clear for GeneratedCodeInfo_Annotation {
+impl crate::Clear for GeneratedCodeInfo_Annotation {
     fn clear(&mut self) {
         self.path.clear();
         self.source_file.clear();
@@ -8449,13 +8449,13 @@
 
 impl ::std::fmt::Debug for GeneratedCodeInfo_Annotation {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for GeneratedCodeInfo_Annotation {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for GeneratedCodeInfo_Annotation {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -9724,13 +9724,13 @@
     \x03\x12\x04\xa1\x06\x19\x1a\
 ";
 
-static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;
+static file_descriptor_proto_lazy: crate::rt::LazyV2<crate::descriptor::FileDescriptorProto> = crate::rt::LazyV2::INIT;
 
-fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
-    ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap()
+fn parse_descriptor_proto() -> crate::descriptor::FileDescriptorProto {
+    crate::parse_from_bytes(file_descriptor_proto_data).unwrap()
 }
 
-pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
+pub fn file_descriptor_proto() -> &'static crate::descriptor::FileDescriptorProto {
     file_descriptor_proto_lazy.get(|| {
         parse_descriptor_proto()
     })
diff --git a/src/descriptorx.rs b/src/descriptorx.rs
index 033aa2a..82baab8 100644
--- a/src/descriptorx.rs
+++ b/src/descriptorx.rs
@@ -1,16 +1,16 @@
 // Should not be a part of public API
 #![doc(hidden)]
 
-use descriptor::DescriptorProto;
-use descriptor::EnumDescriptorProto;
-use descriptor::EnumValueDescriptorProto;
-use descriptor::FieldDescriptorProto;
+use crate::descriptor::DescriptorProto;
+use crate::descriptor::EnumDescriptorProto;
+use crate::descriptor::EnumValueDescriptorProto;
+use crate::descriptor::FieldDescriptorProto;
 /// utilities to work with descriptor
-use descriptor::FileDescriptorProto;
-use descriptor::OneofDescriptorProto;
+use crate::descriptor::FileDescriptorProto;
+use crate::descriptor::OneofDescriptorProto;
 
-use rust;
-use strx;
+use crate::rust;
+use crate::strx;
 
 // Copy-pasted from libsyntax.
 fn ident_start(c: char) -> bool {
diff --git a/src/enums.rs b/src/enums.rs
index 1c2a62e..558d6ff 100644
--- a/src/enums.rs
+++ b/src/enums.rs
@@ -1,5 +1,5 @@
-use reflect::EnumDescriptor;
-use reflect::EnumValueDescriptor;
+use crate::reflect::EnumDescriptor;
+use crate::reflect::EnumValueDescriptor;
 
 /// Trait implemented by all protobuf enum types.
 pub trait ProtobufEnum: Eq + Sized + Copy + 'static {
diff --git a/src/error.rs b/src/error.rs
index 8039baf..9e5a7e1 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -5,7 +5,7 @@
 use std::io;
 use std::str;
 
-use wire_format::WireType;
+use crate::wire_format::WireType;
 
 /// `Result` alias for `ProtobufError`
 pub type ProtobufResult<T> = Result<T, ProtobufError>;
diff --git a/src/ext.rs b/src/ext.rs
index 70b7439..a1c18f6 100644
--- a/src/ext.rs
+++ b/src/ext.rs
@@ -6,8 +6,8 @@
 
 use std::marker::PhantomData;
 
-use core::Message;
-use types::ProtobufType;
+use crate::message::Message;
+use crate::types::ProtobufType;
 
 /// Optional ext field
 pub struct ExtFieldOptional<M: Message, T: ProtobufType> {
diff --git a/src/json/json_name.rs b/src/json/json_name.rs
new file mode 100644
index 0000000..f5c9364
--- /dev/null
+++ b/src/json/json_name.rs
@@ -0,0 +1,19 @@
+/// Implementation must match exactly
+/// `ToJsonName()` function in C++ `descriptor.cc`.
+pub fn json_name(input: &str) -> String {
+    let mut capitalize_next = false;
+    let mut result = String::with_capacity(input.len());
+
+    for c in input.chars() {
+        if c == '_' {
+            capitalize_next = true;
+        } else if capitalize_next {
+            result.extend(c.to_uppercase());
+            capitalize_next = false;
+        } else {
+            result.push(c);
+        }
+    }
+
+    result
+}
diff --git a/src/json/mod.rs b/src/json/mod.rs
new file mode 100644
index 0000000..2755aad
--- /dev/null
+++ b/src/json/mod.rs
@@ -0,0 +1,8 @@
+//! JSON serialization and deserialization.
+//!
+//! (Implemented in master, but not ported to stable branch yet).
+
+mod json_name;
+
+#[doc(hidden)]
+pub use self::json_name::json_name;
diff --git a/src/lib.rs b/src/lib.rs
index 6f5068c..4a346c8 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,7 +1,7 @@
 //! Library to read and write protocol buffers data.
 
 #![deny(missing_docs)]
-#![deny(intra_doc_link_resolution_failure)]
+#![deny(broken_intra_doc_links)]
 // Because we need compat with Rust 1.26
 #![allow(bare_trait_objects)]
 
@@ -12,36 +12,36 @@
 #[macro_use]
 #[cfg(feature = "with-serde")]
 extern crate serde_derive;
-pub use cached_size::CachedSize;
+pub use crate::cached_size::CachedSize;
 #[cfg(feature = "bytes")]
-pub use chars::Chars;
-pub use clear::Clear;
-pub use core::parse_from_bytes;
+pub use crate::chars::Chars;
+pub use crate::clear::Clear;
+pub use crate::enums::ProtobufEnum;
+pub use crate::error::ProtobufError;
+pub use crate::error::ProtobufResult;
+pub use crate::message::parse_from_bytes;
 #[cfg(feature = "bytes")]
-pub use core::parse_from_carllerche_bytes;
-pub use core::parse_from_reader;
+pub use crate::message::parse_from_carllerche_bytes;
+pub use crate::message::parse_from_reader;
 #[allow(deprecated)]
-pub use core::parse_length_delimited_from;
+pub use crate::message::parse_length_delimited_from;
 #[allow(deprecated)]
-pub use core::parse_length_delimited_from_bytes;
+pub use crate::message::parse_length_delimited_from_bytes;
 #[allow(deprecated)]
-pub use core::parse_length_delimited_from_reader;
-pub use core::Message;
-pub use enums::ProtobufEnum;
-pub use error::ProtobufError;
-pub use error::ProtobufResult;
-pub use repeated::RepeatedField;
-pub use singular::SingularField;
-pub use singular::SingularPtrField;
-pub use stream::wire_format;
-pub use stream::CodedInputStream;
-pub use stream::CodedOutputStream;
-pub use unknown::UnknownFields;
-pub use unknown::UnknownFieldsIter;
-pub use unknown::UnknownValue;
-pub use unknown::UnknownValueRef;
-pub use unknown::UnknownValues;
-pub use unknown::UnknownValuesIter;
+pub use crate::message::parse_length_delimited_from_reader;
+pub use crate::message::Message;
+pub use crate::repeated::RepeatedField;
+pub use crate::singular::SingularField;
+pub use crate::singular::SingularPtrField;
+pub use crate::stream::wire_format;
+pub use crate::stream::CodedInputStream;
+pub use crate::stream::CodedOutputStream;
+pub use crate::unknown::UnknownFields;
+pub use crate::unknown::UnknownFieldsIter;
+pub use crate::unknown::UnknownValue;
+pub use crate::unknown::UnknownValueRef;
+pub use crate::unknown::UnknownValues;
+pub use crate::unknown::UnknownValuesIter;
 
 // generated
 pub mod descriptor;
@@ -50,12 +50,13 @@
 
 mod clear;
 pub mod compiler_plugin;
-mod core;
 mod enums;
 pub mod error;
 pub mod ext;
+pub mod json;
 pub mod lazy;
 mod lazy_v2;
+mod message;
 pub mod reflect;
 mod repeated;
 pub mod rt;
@@ -87,34 +88,6 @@
 
 mod buf_read_iter;
 
-// so `use protobuf::*` could work in mod descriptor and well_known_types
-mod protobuf {
-    pub use cached_size::CachedSize;
-    pub use clear::Clear;
-    pub use core::*;
-    pub use descriptor;
-    pub use descriptorx;
-    pub use enums::ProtobufEnum;
-    pub use error::*;
-    pub use ext;
-    pub use lazy;
-    pub use reflect;
-    pub use repeated::RepeatedField;
-    pub use rt;
-    pub use singular::SingularField;
-    pub use singular::SingularPtrField;
-    pub use stream::*;
-    pub use text_format;
-    pub use types;
-    pub use unknown::UnknownFields;
-    pub use unknown::UnknownFieldsIter;
-    pub use unknown::UnknownValue;
-    pub use unknown::UnknownValueRef;
-    pub use unknown::UnknownValues;
-    pub use unknown::UnknownValuesIter;
-    pub use well_known_types;
-}
-
 /// This symbol is in generated `version.rs`, include here for IDE
 #[cfg(never)]
 pub const VERSION: &str = "";
@@ -122,4 +95,4 @@
 #[cfg(never)]
 #[doc(hidden)]
 pub const VERSION_IDENT: &str = "";
-include!("../out/version.rs");
+include!("../out/version.rs");  // ANDROID
diff --git a/src/core.rs b/src/message.rs
similarity index 95%
rename from src/core.rs
rename to src/message.rs
index c577d44..1b1f39f 100644
--- a/src/core.rs
+++ b/src/message.rs
@@ -7,16 +7,16 @@
 #[cfg(feature = "bytes")]
 use bytes::Bytes;
 
-use clear::Clear;
-use error::ProtobufError;
-use error::ProtobufResult;
-use reflect::MessageDescriptor;
-use stream::with_coded_output_stream_to_bytes;
-use stream::CodedInputStream;
-use stream::CodedOutputStream;
-use stream::WithCodedInputStream;
-use stream::WithCodedOutputStream;
-use unknown::UnknownFields;
+use crate::clear::Clear;
+use crate::error::ProtobufError;
+use crate::error::ProtobufResult;
+use crate::reflect::MessageDescriptor;
+use crate::stream::with_coded_output_stream_to_bytes;
+use crate::stream::CodedInputStream;
+use crate::stream::CodedOutputStream;
+use crate::stream::WithCodedInputStream;
+use crate::stream::WithCodedOutputStream;
+use crate::unknown::UnknownFields;
 
 /// Trait implemented for all generated structs for protobuf messages.
 ///
diff --git a/src/plugin.rs b/src/plugin.rs
index 2cceeb9..e3ac18f 100644
--- a/src/plugin.rs
+++ b/src/plugin.rs
@@ -1,4 +1,4 @@
-// This file is generated by rust-protobuf 2.16.0-pre. Do not edit
+// This file is generated by rust-protobuf 2.17.0-pre. Do not edit
 // @generated
 
 // https://github.com/rust-lang/rust-clippy/issues/702
@@ -23,19 +23,19 @@
 #[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
 pub struct CodeGeneratorRequest {
     // message fields
-    pub file_to_generate: ::protobuf::RepeatedField<::std::string::String>,
-    parameter: ::protobuf::SingularField<::std::string::String>,
-    pub proto_file: ::protobuf::RepeatedField<::protobuf::descriptor::FileDescriptorProto>,
+    pub file_to_generate: crate::RepeatedField<::std::string::String>,
+    parameter: crate::SingularField<::std::string::String>,
+    pub proto_file: crate::RepeatedField<crate::descriptor::FileDescriptorProto>,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a CodeGeneratorRequest {
     fn default() -> &'a CodeGeneratorRequest {
-        <CodeGeneratorRequest as ::protobuf::Message>::default_instance()
+        <CodeGeneratorRequest as crate::Message>::default_instance()
     }
 }
 
@@ -55,18 +55,18 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_file_to_generate(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
+    pub fn set_file_to_generate(&mut self, v: crate::RepeatedField<::std::string::String>) {
         self.file_to_generate = v;
     }
 
     // Mutable pointer to the field.
-    pub fn mut_file_to_generate(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
+    pub fn mut_file_to_generate(&mut self) -> &mut crate::RepeatedField<::std::string::String> {
         &mut self.file_to_generate
     }
 
     // Take field
-    pub fn take_file_to_generate(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
-        ::std::mem::replace(&mut self.file_to_generate, ::protobuf::RepeatedField::new())
+    pub fn take_file_to_generate(&mut self) -> crate::RepeatedField<::std::string::String> {
+        ::std::mem::replace(&mut self.file_to_generate, crate::RepeatedField::new())
     }
 
     // optional string parameter = 2;
@@ -88,7 +88,7 @@
 
     // Param is passed by value, moved
     pub fn set_parameter(&mut self, v: ::std::string::String) {
-        self.parameter = ::protobuf::SingularField::some(v);
+        self.parameter = crate::SingularField::some(v);
     }
 
     // Mutable pointer to the field.
@@ -108,7 +108,7 @@
     // repeated .google.protobuf.FileDescriptorProto proto_file = 15;
 
 
-    pub fn get_proto_file(&self) -> &[::protobuf::descriptor::FileDescriptorProto] {
+    pub fn get_proto_file(&self) -> &[crate::descriptor::FileDescriptorProto] {
         &self.proto_file
     }
     pub fn clear_proto_file(&mut self) {
@@ -116,22 +116,22 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_proto_file(&mut self, v: ::protobuf::RepeatedField<::protobuf::descriptor::FileDescriptorProto>) {
+    pub fn set_proto_file(&mut self, v: crate::RepeatedField<crate::descriptor::FileDescriptorProto>) {
         self.proto_file = v;
     }
 
     // Mutable pointer to the field.
-    pub fn mut_proto_file(&mut self) -> &mut ::protobuf::RepeatedField<::protobuf::descriptor::FileDescriptorProto> {
+    pub fn mut_proto_file(&mut self) -> &mut crate::RepeatedField<crate::descriptor::FileDescriptorProto> {
         &mut self.proto_file
     }
 
     // Take field
-    pub fn take_proto_file(&mut self) -> ::protobuf::RepeatedField<::protobuf::descriptor::FileDescriptorProto> {
-        ::std::mem::replace(&mut self.proto_file, ::protobuf::RepeatedField::new())
+    pub fn take_proto_file(&mut self) -> crate::RepeatedField<crate::descriptor::FileDescriptorProto> {
+        ::std::mem::replace(&mut self.proto_file, crate::RepeatedField::new())
     }
 }
 
-impl ::protobuf::Message for CodeGeneratorRequest {
+impl crate::Message for CodeGeneratorRequest {
     fn is_initialized(&self) -> bool {
         for v in &self.proto_file {
             if !v.is_initialized() {
@@ -141,21 +141,21 @@
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::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.file_to_generate)?;
+                    crate::rt::read_repeated_string_into(wire_type, is, &mut self.file_to_generate)?;
                 },
                 2 => {
-                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.parameter)?;
+                    crate::rt::read_singular_string_into(wire_type, is, &mut self.parameter)?;
                 },
                 15 => {
-                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.proto_file)?;
+                    crate::rt::read_repeated_message_into(wire_type, is, &mut self.proto_file)?;
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -167,21 +167,21 @@
     fn compute_size(&self) -> u32 {
         let mut my_size = 0;
         for value in &self.file_to_generate {
-            my_size += ::protobuf::rt::string_size(1, &value);
+            my_size += crate::rt::string_size(1, &value);
         };
         if let Some(ref v) = self.parameter.as_ref() {
-            my_size += ::protobuf::rt::string_size(2, &v);
+            my_size += crate::rt::string_size(2, &v);
         }
         for value in &self.proto_file {
             let len = value.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
         };
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         for v in &self.file_to_generate {
             os.write_string(1, &v)?;
         };
@@ -189,7 +189,7 @@
             os.write_string(2, &v)?;
         }
         for v in &self.proto_file {
-            os.write_tag(15, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(15, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         };
@@ -201,11 +201,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -219,7 +219,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -227,26 +227,26 @@
         CodeGeneratorRequest::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "file_to_generate",
                 |m: &CodeGeneratorRequest| { &m.file_to_generate },
                 |m: &mut CodeGeneratorRequest| { &mut m.file_to_generate },
             ));
-            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "parameter",
                 |m: &CodeGeneratorRequest| { &m.parameter },
                 |m: &mut CodeGeneratorRequest| { &mut m.parameter },
             ));
-            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::descriptor::FileDescriptorProto>>(
+            fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<crate::descriptor::FileDescriptorProto>>(
                 "proto_file",
                 |m: &CodeGeneratorRequest| { &m.proto_file },
                 |m: &mut CodeGeneratorRequest| { &mut m.proto_file },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CodeGeneratorRequest>(
+            crate::reflect::MessageDescriptor::new_pb_name::<CodeGeneratorRequest>(
                 "CodeGeneratorRequest",
                 fields,
                 file_descriptor_proto()
@@ -255,12 +255,12 @@
     }
 
     fn default_instance() -> &'static CodeGeneratorRequest {
-        static instance: ::protobuf::rt::LazyV2<CodeGeneratorRequest> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<CodeGeneratorRequest> = crate::rt::LazyV2::INIT;
         instance.get(CodeGeneratorRequest::new)
     }
 }
 
-impl ::protobuf::Clear for CodeGeneratorRequest {
+impl crate::Clear for CodeGeneratorRequest {
     fn clear(&mut self) {
         self.file_to_generate.clear();
         self.parameter.clear();
@@ -271,13 +271,13 @@
 
 impl ::std::fmt::Debug for CodeGeneratorRequest {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for CodeGeneratorRequest {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for CodeGeneratorRequest {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -285,18 +285,18 @@
 #[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
 pub struct CodeGeneratorResponse {
     // message fields
-    error: ::protobuf::SingularField<::std::string::String>,
-    pub file: ::protobuf::RepeatedField<CodeGeneratorResponse_File>,
+    error: crate::SingularField<::std::string::String>,
+    pub file: crate::RepeatedField<CodeGeneratorResponse_File>,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a CodeGeneratorResponse {
     fn default() -> &'a CodeGeneratorResponse {
-        <CodeGeneratorResponse as ::protobuf::Message>::default_instance()
+        <CodeGeneratorResponse as crate::Message>::default_instance()
     }
 }
 
@@ -324,7 +324,7 @@
 
     // Param is passed by value, moved
     pub fn set_error(&mut self, v: ::std::string::String) {
-        self.error = ::protobuf::SingularField::some(v);
+        self.error = crate::SingularField::some(v);
     }
 
     // Mutable pointer to the field.
@@ -352,22 +352,22 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_file(&mut self, v: ::protobuf::RepeatedField<CodeGeneratorResponse_File>) {
+    pub fn set_file(&mut self, v: crate::RepeatedField<CodeGeneratorResponse_File>) {
         self.file = v;
     }
 
     // Mutable pointer to the field.
-    pub fn mut_file(&mut self) -> &mut ::protobuf::RepeatedField<CodeGeneratorResponse_File> {
+    pub fn mut_file(&mut self) -> &mut crate::RepeatedField<CodeGeneratorResponse_File> {
         &mut self.file
     }
 
     // Take field
-    pub fn take_file(&mut self) -> ::protobuf::RepeatedField<CodeGeneratorResponse_File> {
-        ::std::mem::replace(&mut self.file, ::protobuf::RepeatedField::new())
+    pub fn take_file(&mut self) -> crate::RepeatedField<CodeGeneratorResponse_File> {
+        ::std::mem::replace(&mut self.file, crate::RepeatedField::new())
     }
 }
 
-impl ::protobuf::Message for CodeGeneratorResponse {
+impl crate::Message for CodeGeneratorResponse {
     fn is_initialized(&self) -> bool {
         for v in &self.file {
             if !v.is_initialized() {
@@ -377,18 +377,18 @@
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
         while !is.eof()? {
             let (field_number, wire_type) = is.read_tag_unpack()?;
             match field_number {
                 1 => {
-                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.error)?;
+                    crate::rt::read_singular_string_into(wire_type, is, &mut self.error)?;
                 },
                 15 => {
-                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.file)?;
+                    crate::rt::read_repeated_message_into(wire_type, is, &mut self.file)?;
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -400,23 +400,23 @@
     fn compute_size(&self) -> u32 {
         let mut my_size = 0;
         if let Some(ref v) = self.error.as_ref() {
-            my_size += ::protobuf::rt::string_size(1, &v);
+            my_size += crate::rt::string_size(1, &v);
         }
         for value in &self.file {
             let len = value.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
         };
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         if let Some(ref v) = self.error.as_ref() {
             os.write_string(1, &v)?;
         }
         for v in &self.file {
-            os.write_tag(15, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(15, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         };
@@ -428,11 +428,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -446,7 +446,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -454,21 +454,21 @@
         CodeGeneratorResponse::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "error",
                 |m: &CodeGeneratorResponse| { &m.error },
                 |m: &mut CodeGeneratorResponse| { &mut m.error },
             ));
-            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<CodeGeneratorResponse_File>>(
+            fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<CodeGeneratorResponse_File>>(
                 "file",
                 |m: &CodeGeneratorResponse| { &m.file },
                 |m: &mut CodeGeneratorResponse| { &mut m.file },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CodeGeneratorResponse>(
+            crate::reflect::MessageDescriptor::new_pb_name::<CodeGeneratorResponse>(
                 "CodeGeneratorResponse",
                 fields,
                 file_descriptor_proto()
@@ -477,12 +477,12 @@
     }
 
     fn default_instance() -> &'static CodeGeneratorResponse {
-        static instance: ::protobuf::rt::LazyV2<CodeGeneratorResponse> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<CodeGeneratorResponse> = crate::rt::LazyV2::INIT;
         instance.get(CodeGeneratorResponse::new)
     }
 }
 
-impl ::protobuf::Clear for CodeGeneratorResponse {
+impl crate::Clear for CodeGeneratorResponse {
     fn clear(&mut self) {
         self.error.clear();
         self.file.clear();
@@ -492,13 +492,13 @@
 
 impl ::std::fmt::Debug for CodeGeneratorResponse {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for CodeGeneratorResponse {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for CodeGeneratorResponse {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -506,19 +506,19 @@
 #[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
 pub struct CodeGeneratorResponse_File {
     // message fields
-    name: ::protobuf::SingularField<::std::string::String>,
-    insertion_point: ::protobuf::SingularField<::std::string::String>,
-    content: ::protobuf::SingularField<::std::string::String>,
+    name: crate::SingularField<::std::string::String>,
+    insertion_point: crate::SingularField<::std::string::String>,
+    content: crate::SingularField<::std::string::String>,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a CodeGeneratorResponse_File {
     fn default() -> &'a CodeGeneratorResponse_File {
-        <CodeGeneratorResponse_File as ::protobuf::Message>::default_instance()
+        <CodeGeneratorResponse_File as crate::Message>::default_instance()
     }
 }
 
@@ -546,7 +546,7 @@
 
     // Param is passed by value, moved
     pub fn set_name(&mut self, v: ::std::string::String) {
-        self.name = ::protobuf::SingularField::some(v);
+        self.name = crate::SingularField::some(v);
     }
 
     // Mutable pointer to the field.
@@ -582,7 +582,7 @@
 
     // Param is passed by value, moved
     pub fn set_insertion_point(&mut self, v: ::std::string::String) {
-        self.insertion_point = ::protobuf::SingularField::some(v);
+        self.insertion_point = crate::SingularField::some(v);
     }
 
     // Mutable pointer to the field.
@@ -618,7 +618,7 @@
 
     // Param is passed by value, moved
     pub fn set_content(&mut self, v: ::std::string::String) {
-        self.content = ::protobuf::SingularField::some(v);
+        self.content = crate::SingularField::some(v);
     }
 
     // Mutable pointer to the field.
@@ -636,26 +636,26 @@
     }
 }
 
-impl ::protobuf::Message for CodeGeneratorResponse_File {
+impl crate::Message for CodeGeneratorResponse_File {
     fn is_initialized(&self) -> bool {
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
         while !is.eof()? {
             let (field_number, wire_type) = is.read_tag_unpack()?;
             match field_number {
                 1 => {
-                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.name)?;
+                    crate::rt::read_singular_string_into(wire_type, is, &mut self.name)?;
                 },
                 2 => {
-                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.insertion_point)?;
+                    crate::rt::read_singular_string_into(wire_type, is, &mut self.insertion_point)?;
                 },
                 15 => {
-                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.content)?;
+                    crate::rt::read_singular_string_into(wire_type, is, &mut self.content)?;
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -667,20 +667,20 @@
     fn compute_size(&self) -> u32 {
         let mut my_size = 0;
         if let Some(ref v) = self.name.as_ref() {
-            my_size += ::protobuf::rt::string_size(1, &v);
+            my_size += crate::rt::string_size(1, &v);
         }
         if let Some(ref v) = self.insertion_point.as_ref() {
-            my_size += ::protobuf::rt::string_size(2, &v);
+            my_size += crate::rt::string_size(2, &v);
         }
         if let Some(ref v) = self.content.as_ref() {
-            my_size += ::protobuf::rt::string_size(15, &v);
+            my_size += crate::rt::string_size(15, &v);
         }
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         if let Some(ref v) = self.name.as_ref() {
             os.write_string(1, &v)?;
         }
@@ -698,11 +698,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -716,7 +716,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -724,26 +724,26 @@
         CodeGeneratorResponse_File::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "name",
                 |m: &CodeGeneratorResponse_File| { &m.name },
                 |m: &mut CodeGeneratorResponse_File| { &mut m.name },
             ));
-            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "insertion_point",
                 |m: &CodeGeneratorResponse_File| { &m.insertion_point },
                 |m: &mut CodeGeneratorResponse_File| { &mut m.insertion_point },
             ));
-            fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_singular_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "content",
                 |m: &CodeGeneratorResponse_File| { &m.content },
                 |m: &mut CodeGeneratorResponse_File| { &mut m.content },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CodeGeneratorResponse_File>(
+            crate::reflect::MessageDescriptor::new_pb_name::<CodeGeneratorResponse_File>(
                 "CodeGeneratorResponse.File",
                 fields,
                 file_descriptor_proto()
@@ -752,12 +752,12 @@
     }
 
     fn default_instance() -> &'static CodeGeneratorResponse_File {
-        static instance: ::protobuf::rt::LazyV2<CodeGeneratorResponse_File> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<CodeGeneratorResponse_File> = crate::rt::LazyV2::INIT;
         instance.get(CodeGeneratorResponse_File::new)
     }
 }
 
-impl ::protobuf::Clear for CodeGeneratorResponse_File {
+impl crate::Clear for CodeGeneratorResponse_File {
     fn clear(&mut self) {
         self.name.clear();
         self.insertion_point.clear();
@@ -768,13 +768,13 @@
 
 impl ::std::fmt::Debug for CodeGeneratorResponse_File {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for CodeGeneratorResponse_File {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for CodeGeneratorResponse_File {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -968,13 +968,13 @@
     \x02\x01\x03\x12\x04\x94\x01\x17\x19\
 ";
 
-static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;
+static file_descriptor_proto_lazy: crate::rt::LazyV2<crate::descriptor::FileDescriptorProto> = crate::rt::LazyV2::INIT;
 
-fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
-    ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap()
+fn parse_descriptor_proto() -> crate::descriptor::FileDescriptorProto {
+    crate::parse_from_bytes(file_descriptor_proto_data).unwrap()
 }
 
-pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
+pub fn file_descriptor_proto() -> &'static crate::descriptor::FileDescriptorProto {
     file_descriptor_proto_lazy.get(|| {
         parse_descriptor_proto()
     })
diff --git a/src/reflect/acc/mod.rs b/src/reflect/acc/mod.rs
new file mode 100644
index 0000000..288c183
--- /dev/null
+++ b/src/reflect/acc/mod.rs
@@ -0,0 +1,31 @@
+#![doc(hidden)]
+
+use crate::reflect::acc::v1::FieldAccessorFunctions;
+use crate::reflect::acc::v1::FieldAccessorImpl;
+use crate::reflect::acc::v1::FieldAccessorTrait;
+use crate::Message;
+
+pub(crate) mod v1;
+
+pub(crate) enum Accessor {
+    V1(Box<dyn FieldAccessorTrait + 'static>),
+}
+
+/// Accessor object is constructed in generated code.
+/// Should not be used directly.
+pub struct FieldAccessor {
+    pub(crate) name: &'static str,
+    pub(crate) accessor: Accessor,
+}
+
+impl FieldAccessor {
+    pub(crate) fn new_v1<M: Message>(
+        name: &'static str,
+        fns: FieldAccessorFunctions<M>,
+    ) -> FieldAccessor {
+        FieldAccessor {
+            name,
+            accessor: Accessor::V1(Box::new(FieldAccessorImpl { fns })),
+        }
+    }
+}
diff --git a/src/reflect/accessor.rs b/src/reflect/acc/v1.rs
similarity index 60%
rename from src/reflect/accessor.rs
rename to src/reflect/acc/v1.rs
index 9f04838..5cf53d5 100644
--- a/src/reflect/accessor.rs
+++ b/src/reflect/acc/v1.rs
@@ -1,51 +1,52 @@
 #![doc(hidden)]
 
+//! Version 1 reflection accessors.
+
 use std::collections::HashMap;
 use std::fmt;
 use std::hash::Hash;
 
-use core::message_down_cast;
-use core::Message;
-use enums::ProtobufEnum;
-use reflect::EnumValueDescriptor;
-use types::*;
+use crate::enums::ProtobufEnum;
+use crate::message::message_down_cast;
+use crate::message::Message;
+use crate::reflect::EnumValueDescriptor;
+use crate::reflect::ProtobufValue;
+use crate::reflect::ReflectFieldRef;
+use crate::reflect::ReflectValueRef;
+use crate::types::*;
 
-use repeated::RepeatedField;
-use singular::SingularField;
-use singular::SingularPtrField;
-
-use super::map::ReflectMap;
-use super::optional::ReflectOptional;
-use super::repeated::ReflectRepeated;
-use super::repeated::ReflectRepeatedEnum;
-use super::repeated::ReflectRepeatedMessage;
-use super::value::ProtobufValue;
-use super::value::ReflectValueRef;
-use super::ReflectFieldRef;
+use crate::reflect::map::ReflectMap;
+use crate::reflect::optional::ReflectOptional;
+use crate::reflect::repeated::ReflectRepeated;
+use crate::reflect::repeated::ReflectRepeatedEnum;
+use crate::reflect::repeated::ReflectRepeatedMessage;
+use crate::reflect::rt::FieldAccessor;
+use crate::repeated::RepeatedField;
+use crate::singular::SingularField;
+use crate::singular::SingularPtrField;
 
 /// this trait should not be used directly, use `FieldDescriptor` instead
-pub trait FieldAccessor: Sync {
-    fn name_generic(&self) -> &'static str;
-    fn has_field_generic(&self, m: &Message) -> bool;
-    fn len_field_generic(&self, m: &Message) -> usize;
+pub trait FieldAccessorTrait: Sync + 'static {
+    fn has_field_generic(&self, m: &dyn Message) -> bool;
+    fn len_field_generic(&self, m: &dyn Message) -> usize;
     // TODO: should it return default value or panic on unset field?
-    fn get_message_generic<'a>(&self, m: &'a Message) -> &'a Message;
-    fn get_enum_generic(&self, m: &Message) -> &'static EnumValueDescriptor;
-    fn get_str_generic<'a>(&self, m: &'a Message) -> &'a str;
-    fn get_bytes_generic<'a>(&self, m: &'a Message) -> &'a [u8];
-    fn get_u32_generic(&self, m: &Message) -> u32;
-    fn get_u64_generic(&self, m: &Message) -> u64;
-    fn get_i32_generic(&self, m: &Message) -> i32;
-    fn get_i64_generic(&self, m: &Message) -> i64;
-    fn get_bool_generic(&self, m: &Message) -> bool;
-    fn get_f32_generic(&self, m: &Message) -> f32;
-    fn get_f64_generic(&self, m: &Message) -> f64;
+    fn get_message_generic<'a>(&self, m: &'a dyn Message) -> &'a dyn Message;
+    fn get_enum_generic(&self, m: &dyn Message) -> &'static EnumValueDescriptor;
+    fn get_str_generic<'a>(&self, m: &'a dyn Message) -> &'a str;
+    fn get_bytes_generic<'a>(&self, m: &'a dyn Message) -> &'a [u8];
+    fn get_u32_generic(&self, m: &dyn Message) -> u32;
+    fn get_u64_generic(&self, m: &dyn Message) -> u64;
+    fn get_i32_generic(&self, m: &dyn Message) -> i32;
+    fn get_i64_generic(&self, m: &dyn Message) -> i64;
+    fn get_bool_generic(&self, m: &dyn Message) -> bool;
+    fn get_f32_generic(&self, m: &dyn Message) -> f32;
+    fn get_f64_generic(&self, m: &dyn Message) -> f64;
 
-    fn get_reflect<'a>(&self, m: &'a Message) -> ReflectFieldRef<'a>;
+    fn get_reflect<'a>(&self, m: &'a dyn Message) -> ReflectFieldRef<'a>;
 }
 
-trait GetSingularMessage<M>: Sync {
-    fn get_message<'a>(&self, m: &'a M) -> &'a Message;
+pub(crate) trait GetSingularMessage<M>: Sync {
+    fn get_message<'a>(&self, m: &'a M) -> &'a dyn Message;
 }
 
 struct GetSingularMessageImpl<M, N> {
@@ -53,12 +54,12 @@
 }
 
 impl<M: Message, N: Message + 'static> GetSingularMessage<M> for GetSingularMessageImpl<M, N> {
-    fn get_message<'a>(&self, m: &'a M) -> &'a Message {
+    fn get_message<'a>(&self, m: &'a M) -> &'a dyn Message {
         (self.get)(m)
     }
 }
 
-trait GetSingularEnum<M>: Sync {
+pub(crate) trait GetSingularEnum<M>: Sync {
     fn get_enum(&self, m: &M) -> &'static EnumValueDescriptor;
 }
 
@@ -74,17 +75,17 @@
 
 trait GetRepeatedMessage<M>: Sync {
     fn len_field(&self, m: &M) -> usize;
-    fn get_message_item<'a>(&self, m: &'a M, index: usize) -> &'a Message;
-    fn reflect_repeated_message<'a>(&self, m: &'a M) -> Box<ReflectRepeatedMessage<'a> + 'a>;
+    fn get_message_item<'a>(&self, m: &'a M, index: usize) -> &'a dyn Message;
+    fn reflect_repeated_message<'a>(&self, m: &'a M) -> Box<dyn ReflectRepeatedMessage<'a> + 'a>;
 }
 
 trait GetRepeatedEnum<M: Message + 'static>: Sync {
     fn len_field(&self, m: &M) -> usize;
     fn get_enum_item(&self, m: &M, index: usize) -> &'static EnumValueDescriptor;
-    fn reflect_repeated_enum<'a>(&self, m: &'a M) -> Box<ReflectRepeatedEnum<'a> + 'a>;
+    fn reflect_repeated_enum<'a>(&self, m: &'a M) -> Box<dyn ReflectRepeatedEnum<'a> + 'a>;
 }
 
-trait GetSetCopyFns<M>: Sync {
+pub(crate) trait GetSetCopyFns<M>: Sync {
     fn get_field<'a>(&self, m: &'a M) -> ReflectValueRef<'a>;
 }
 
@@ -95,16 +96,16 @@
 
 impl<M, V: ProtobufValue + Copy> GetSetCopyFns<M> for GetSetCopyFnsImpl<M, V> {
     fn get_field<'a>(&self, m: &'a M) -> ReflectValueRef<'a> {
-        (&(self.get)(m) as &ProtobufValue).as_ref_copy()
+        (&(self.get)(m) as &dyn ProtobufValue).as_ref_copy()
     }
 }
 
-enum SingularGetSet<M> {
-    Copy(Box<GetSetCopyFns<M>>),
+pub(crate) enum SingularGetSet<M> {
+    Copy(Box<dyn GetSetCopyFns<M>>),
     String(for<'a> fn(&'a M) -> &'a str, fn(&mut M, String)),
     Bytes(for<'a> fn(&'a M) -> &'a [u8], fn(&mut M, Vec<u8>)),
-    Enum(Box<GetSingularEnum<M> + 'static>),
-    Message(Box<GetSingularMessage<M> + 'static>),
+    Enum(Box<dyn GetSingularEnum<M> + 'static>),
+    Message(Box<dyn GetSingularMessage<M> + 'static>),
 }
 
 impl<M: Message + 'static> SingularGetSet<M> {
@@ -119,12 +120,12 @@
     }
 }
 
-trait FieldAccessor2<M, R: ?Sized>: Sync
+pub(crate) trait FieldAccessor2<M, R: ?Sized>: Sync
 where
     M: Message + 'static,
 {
-    fn get_field<'a>(&self, &'a M) -> &'a R;
-    fn mut_field<'a>(&self, &'a mut M) -> &'a mut R;
+    fn get_field<'a>(&self, _: &'a M) -> &'a R;
+    fn mut_field<'a>(&self, _: &'a mut M) -> &'a mut R;
 }
 
 struct MessageGetMut<M, L>
@@ -135,20 +136,20 @@
     mut_field: for<'a> fn(&'a mut M) -> &'a mut L,
 }
 
-enum FieldAccessorFunctions<M> {
+pub(crate) enum FieldAccessorFunctions<M> {
     // up to 1.0.24 optional or required
     SingularHasGetSet {
         has: fn(&M) -> bool,
         get_set: SingularGetSet<M>,
     },
     // protobuf 3 simple field
-    Simple(Box<FieldAccessor2<M, ProtobufValue>>),
+    Simple(Box<dyn FieldAccessor2<M, dyn ProtobufValue>>),
     // optional, required or message
-    Optional(Box<FieldAccessor2<M, ReflectOptional>>),
+    Optional(Box<dyn FieldAccessor2<M, dyn ReflectOptional>>),
     // repeated
-    Repeated(Box<FieldAccessor2<M, ReflectRepeated>>),
+    Repeated(Box<dyn FieldAccessor2<M, dyn ReflectRepeated>>),
     // protobuf 3 map
-    Map(Box<FieldAccessor2<M, ReflectMap>>),
+    Map(Box<dyn FieldAccessor2<M, dyn ReflectMap>>),
 }
 
 impl<M> fmt::Debug for FieldAccessorFunctions<M> {
@@ -165,9 +166,8 @@
     }
 }
 
-struct FieldAccessorImpl<M> {
-    name: &'static str,
-    fns: FieldAccessorFunctions<M>,
+pub(crate) struct FieldAccessorImpl<M> {
+    pub(crate) fns: FieldAccessorFunctions<M>,
 }
 
 impl<M: Message> FieldAccessorImpl<M> {
@@ -194,12 +194,8 @@
     }
 }
 
-impl<M: Message + 'static> FieldAccessor for FieldAccessorImpl<M> {
-    fn name_generic(&self) -> &'static str {
-        self.name
-    }
-
-    fn has_field_generic(&self, m: &Message) -> bool {
+impl<M: Message + 'static> FieldAccessorTrait for FieldAccessorImpl<M> {
+    fn has_field_generic(&self, m: &dyn Message) -> bool {
         match self.fns {
             FieldAccessorFunctions::SingularHasGetSet { has, .. } => has(message_down_cast(m)),
             FieldAccessorFunctions::Optional(ref a) => {
@@ -214,7 +210,7 @@
         }
     }
 
-    fn len_field_generic(&self, m: &Message) -> usize {
+    fn len_field_generic(&self, m: &dyn Message) -> usize {
         match self.fns {
             FieldAccessorFunctions::Repeated(ref a) => a.get_field(message_down_cast(m)).len(),
             FieldAccessorFunctions::Map(ref a) => a.get_field(message_down_cast(m)).len(),
@@ -226,7 +222,7 @@
         }
     }
 
-    fn get_message_generic<'a>(&self, m: &'a Message) -> &'a Message {
+    fn get_message_generic<'a>(&self, m: &'a dyn Message) -> &'a dyn Message {
         match self.fns {
             FieldAccessorFunctions::SingularHasGetSet {
                 get_set: SingularGetSet::Message(ref get),
@@ -247,7 +243,7 @@
         }
     }
 
-    fn get_enum_generic(&self, m: &Message) -> &'static EnumValueDescriptor {
+    fn get_enum_generic(&self, m: &dyn Message) -> &'static EnumValueDescriptor {
         match self.fns {
             FieldAccessorFunctions::SingularHasGetSet {
                 get_set: SingularGetSet::Enum(ref get),
@@ -257,7 +253,7 @@
         }
     }
 
-    fn get_str_generic<'a>(&self, m: &'a Message) -> &'a str {
+    fn get_str_generic<'a>(&self, m: &'a dyn Message) -> &'a str {
         match self.get_value_option(message_down_cast(m)) {
             Some(ReflectValueRef::String(v)) => v,
             Some(_) => panic!("wrong type"),
@@ -265,7 +261,7 @@
         }
     }
 
-    fn get_bytes_generic<'a>(&self, m: &'a Message) -> &'a [u8] {
+    fn get_bytes_generic<'a>(&self, m: &'a dyn Message) -> &'a [u8] {
         match self.get_value_option(message_down_cast(m)) {
             Some(ReflectValueRef::Bytes(v)) => v,
             Some(_) => panic!("wrong type"),
@@ -273,7 +269,7 @@
         }
     }
 
-    fn get_u32_generic(&self, m: &Message) -> u32 {
+    fn get_u32_generic(&self, m: &dyn Message) -> u32 {
         match self.get_value_option(message_down_cast(m)) {
             Some(ReflectValueRef::U32(v)) => v,
             Some(_) => panic!("wrong type"),
@@ -281,7 +277,7 @@
         }
     }
 
-    fn get_u64_generic(&self, m: &Message) -> u64 {
+    fn get_u64_generic(&self, m: &dyn Message) -> u64 {
         match self.get_value_option(message_down_cast(m)) {
             Some(ReflectValueRef::U64(v)) => v,
             Some(_) => panic!("wrong type"),
@@ -289,7 +285,7 @@
         }
     }
 
-    fn get_i32_generic(&self, m: &Message) -> i32 {
+    fn get_i32_generic(&self, m: &dyn Message) -> i32 {
         match self.get_value_option(message_down_cast(m)) {
             Some(ReflectValueRef::I32(v)) => v,
             Some(_) => panic!("wrong type"),
@@ -297,7 +293,7 @@
         }
     }
 
-    fn get_i64_generic(&self, m: &Message) -> i64 {
+    fn get_i64_generic(&self, m: &dyn Message) -> i64 {
         match self.get_value_option(message_down_cast(m)) {
             Some(ReflectValueRef::I64(v)) => v,
             Some(_) => panic!("wrong type"),
@@ -305,23 +301,7 @@
         }
     }
 
-    fn get_f32_generic(&self, m: &Message) -> f32 {
-        match self.get_value_option(message_down_cast(m)) {
-            Some(ReflectValueRef::F32(v)) => v,
-            Some(_) => panic!("wrong type"),
-            None => 0.0, // TODO: check type
-        }
-    }
-
-    fn get_f64_generic(&self, m: &Message) -> f64 {
-        match self.get_value_option(message_down_cast(m)) {
-            Some(ReflectValueRef::F64(v)) => v,
-            Some(_) => panic!("wrong type"),
-            None => 0.0, // TODO: check type
-        }
-    }
-
-    fn get_bool_generic(&self, m: &Message) -> bool {
+    fn get_bool_generic(&self, m: &dyn Message) -> bool {
         match self.get_value_option(message_down_cast(m)) {
             Some(ReflectValueRef::Bool(v)) => v,
             Some(_) => panic!("wrong type"),
@@ -329,7 +309,23 @@
         }
     }
 
-    fn get_reflect<'a>(&self, m: &'a Message) -> ReflectFieldRef<'a> {
+    fn get_f32_generic(&self, m: &dyn Message) -> f32 {
+        match self.get_value_option(message_down_cast(m)) {
+            Some(ReflectValueRef::F32(v)) => v,
+            Some(_) => panic!("wrong type"),
+            None => 0.0, // TODO: check type
+        }
+    }
+
+    fn get_f64_generic(&self, m: &dyn Message) -> f64 {
+        match self.get_value_option(message_down_cast(m)) {
+            Some(ReflectValueRef::F64(v)) => v,
+            Some(_) => panic!("wrong type"),
+            None => 0.0, // TODO: check type
+        }
+    }
+
+    fn get_reflect<'a>(&self, m: &'a dyn Message) -> ReflectFieldRef<'a> {
         match self.fns {
             FieldAccessorFunctions::Repeated(ref accessor2) => {
                 ReflectFieldRef::Repeated(accessor2.get_field(message_down_cast(m)))
@@ -376,190 +372,190 @@
     name: &'static str,
     has: fn(&M) -> bool,
     get: fn(&M) -> u32,
-) -> Box<FieldAccessor + 'static> {
-    Box::new(FieldAccessorImpl {
-        name: name,
-        fns: FieldAccessorFunctions::SingularHasGetSet {
-            has: has,
+) -> FieldAccessor {
+    FieldAccessor::new_v1(
+        name,
+        FieldAccessorFunctions::SingularHasGetSet {
+            has,
             get_set: SingularGetSet::Copy(Box::new(GetSetCopyFnsImpl {
-                get: get,
+                get,
                 _set: set_panic,
             })),
         },
-    })
+    )
 }
 
 pub fn make_singular_i32_accessor<M: Message + 'static>(
     name: &'static str,
     has: fn(&M) -> bool,
     get: fn(&M) -> i32,
-) -> Box<FieldAccessor + 'static> {
-    Box::new(FieldAccessorImpl {
-        name: name,
-        fns: FieldAccessorFunctions::SingularHasGetSet {
-            has: has,
+) -> FieldAccessor {
+    FieldAccessor::new_v1(
+        name,
+        FieldAccessorFunctions::SingularHasGetSet {
+            has,
             get_set: SingularGetSet::Copy(Box::new(GetSetCopyFnsImpl {
-                get: get,
+                get,
                 _set: set_panic,
             })),
         },
-    })
+    )
 }
 
 pub fn make_singular_u64_accessor<M: Message + 'static>(
     name: &'static str,
     has: fn(&M) -> bool,
     get: fn(&M) -> u64,
-) -> Box<FieldAccessor + 'static> {
-    Box::new(FieldAccessorImpl {
-        name: name,
-        fns: FieldAccessorFunctions::SingularHasGetSet {
-            has: has,
+) -> FieldAccessor {
+    FieldAccessor::new_v1(
+        name,
+        FieldAccessorFunctions::SingularHasGetSet {
+            has,
             get_set: SingularGetSet::Copy(Box::new(GetSetCopyFnsImpl {
-                get: get,
+                get,
                 _set: set_panic,
             })),
         },
-    })
+    )
 }
 
 pub fn make_singular_i64_accessor<M: Message + 'static>(
     name: &'static str,
     has: fn(&M) -> bool,
     get: fn(&M) -> i64,
-) -> Box<FieldAccessor + 'static> {
-    Box::new(FieldAccessorImpl {
-        name: name,
-        fns: FieldAccessorFunctions::SingularHasGetSet {
-            has: has,
+) -> FieldAccessor {
+    FieldAccessor::new_v1(
+        name,
+        FieldAccessorFunctions::SingularHasGetSet {
+            has,
             get_set: SingularGetSet::Copy(Box::new(GetSetCopyFnsImpl {
-                get: get,
+                get,
                 _set: set_panic,
             })),
         },
-    })
+    )
 }
 
 pub fn make_singular_f32_accessor<M: Message + 'static>(
     name: &'static str,
     has: fn(&M) -> bool,
     get: fn(&M) -> f32,
-) -> Box<FieldAccessor + 'static> {
-    Box::new(FieldAccessorImpl {
-        name: name,
-        fns: FieldAccessorFunctions::SingularHasGetSet {
-            has: has,
+) -> FieldAccessor {
+    FieldAccessor::new_v1(
+        name,
+        FieldAccessorFunctions::SingularHasGetSet {
+            has,
             get_set: SingularGetSet::Copy(Box::new(GetSetCopyFnsImpl {
-                get: get,
+                get,
                 _set: set_panic,
             })),
         },
-    })
+    )
 }
 
 pub fn make_singular_f64_accessor<M: Message + 'static>(
     name: &'static str,
     has: fn(&M) -> bool,
     get: fn(&M) -> f64,
-) -> Box<FieldAccessor + 'static> {
-    Box::new(FieldAccessorImpl {
-        name: name,
-        fns: FieldAccessorFunctions::SingularHasGetSet {
-            has: has,
+) -> FieldAccessor {
+    FieldAccessor::new_v1(
+        name,
+        FieldAccessorFunctions::SingularHasGetSet {
+            has,
             get_set: SingularGetSet::Copy(Box::new(GetSetCopyFnsImpl {
-                get: get,
+                get,
                 _set: set_panic,
             })),
         },
-    })
+    )
 }
 
 pub fn make_singular_bool_accessor<M: Message + 'static>(
     name: &'static str,
     has: fn(&M) -> bool,
     get: fn(&M) -> bool,
-) -> Box<FieldAccessor + 'static> {
-    Box::new(FieldAccessorImpl {
-        name: name,
-        fns: FieldAccessorFunctions::SingularHasGetSet {
-            has: has,
+) -> FieldAccessor {
+    FieldAccessor::new_v1(
+        name,
+        FieldAccessorFunctions::SingularHasGetSet {
+            has,
             get_set: SingularGetSet::Copy(Box::new(GetSetCopyFnsImpl {
-                get: get,
+                get,
                 _set: set_panic,
             })),
         },
-    })
+    )
 }
 
 pub fn make_singular_enum_accessor<M: Message + 'static, E: ProtobufEnum + 'static>(
     name: &'static str,
     has: fn(&M) -> bool,
     get: fn(&M) -> E,
-) -> Box<FieldAccessor + 'static> {
-    Box::new(FieldAccessorImpl {
-        name: name,
-        fns: FieldAccessorFunctions::SingularHasGetSet {
-            has: has,
-            get_set: SingularGetSet::Enum(Box::new(GetSingularEnumImpl { get: get })),
+) -> FieldAccessor {
+    FieldAccessor::new_v1(
+        name,
+        FieldAccessorFunctions::SingularHasGetSet {
+            has,
+            get_set: SingularGetSet::Enum(Box::new(GetSingularEnumImpl { get })),
         },
-    })
+    )
 }
 
 pub fn make_singular_string_accessor<M: Message + 'static>(
     name: &'static str,
     has: fn(&M) -> bool,
     get: for<'a> fn(&'a M) -> &'a str,
-) -> Box<FieldAccessor + 'static> {
-    Box::new(FieldAccessorImpl {
-        name: name,
-        fns: FieldAccessorFunctions::SingularHasGetSet {
-            has: has,
+) -> FieldAccessor {
+    FieldAccessor::new_v1(
+        name,
+        FieldAccessorFunctions::SingularHasGetSet {
+            has,
             get_set: SingularGetSet::String(get, set_panic),
         },
-    })
+    )
 }
 
 pub fn make_singular_bytes_accessor<M: Message + 'static>(
     name: &'static str,
     has: fn(&M) -> bool,
     get: for<'a> fn(&'a M) -> &'a [u8],
-) -> Box<FieldAccessor + 'static> {
-    Box::new(FieldAccessorImpl {
-        name: name,
-        fns: FieldAccessorFunctions::SingularHasGetSet {
-            has: has,
+) -> FieldAccessor {
+    FieldAccessor::new_v1(
+        name,
+        FieldAccessorFunctions::SingularHasGetSet {
+            has,
             get_set: SingularGetSet::Bytes(get, set_panic),
         },
-    })
+    )
 }
 
 pub fn make_singular_message_accessor<M: Message + 'static, F: Message + 'static>(
     name: &'static str,
     has: fn(&M) -> bool,
     get: for<'a> fn(&'a M) -> &'a F,
-) -> Box<FieldAccessor + 'static> {
-    Box::new(FieldAccessorImpl {
-        name: name,
-        fns: FieldAccessorFunctions::SingularHasGetSet {
-            has: has,
-            get_set: SingularGetSet::Message(Box::new(GetSingularMessageImpl { get: get })),
+) -> FieldAccessor {
+    FieldAccessor::new_v1(
+        name,
+        FieldAccessorFunctions::SingularHasGetSet {
+            has,
+            get_set: SingularGetSet::Message(Box::new(GetSingularMessageImpl { get })),
         },
-    })
+    )
 }
 
 // repeated
 
-impl<M, V> FieldAccessor2<M, ReflectRepeated> for MessageGetMut<M, Vec<V>>
+impl<M, V> FieldAccessor2<M, dyn ReflectRepeated> for MessageGetMut<M, Vec<V>>
 where
     M: Message + 'static,
     V: ProtobufValue + 'static,
 {
-    fn get_field<'a>(&self, m: &'a M) -> &'a ReflectRepeated {
-        (self.get_field)(m) as &ReflectRepeated
+    fn get_field<'a>(&self, m: &'a M) -> &'a dyn ReflectRepeated {
+        (self.get_field)(m) as &dyn ReflectRepeated
     }
 
-    fn mut_field<'a>(&self, m: &'a mut M) -> &'a mut ReflectRepeated {
-        (self.mut_field)(m) as &mut ReflectRepeated
+    fn mut_field<'a>(&self, m: &'a mut M) -> &'a mut dyn ReflectRepeated {
+        (self.mut_field)(m) as &mut dyn ReflectRepeated
     }
 }
 
@@ -567,31 +563,31 @@
     name: &'static str,
     get_vec: for<'a> fn(&'a M) -> &'a Vec<V::Value>,
     mut_vec: for<'a> fn(&'a mut M) -> &'a mut Vec<V::Value>,
-) -> Box<FieldAccessor + 'static>
+) -> FieldAccessor
 where
     M: Message + 'static,
     V: ProtobufType + 'static,
 {
-    Box::new(FieldAccessorImpl {
-        name: name,
-        fns: FieldAccessorFunctions::Repeated(Box::new(MessageGetMut::<M, Vec<V::Value>> {
+    FieldAccessor::new_v1(
+        name,
+        FieldAccessorFunctions::Repeated(Box::new(MessageGetMut::<M, Vec<V::Value>> {
             get_field: get_vec,
             mut_field: mut_vec,
         })),
-    })
+    )
 }
 
-impl<M, V> FieldAccessor2<M, ReflectRepeated> for MessageGetMut<M, RepeatedField<V>>
+impl<M, V> FieldAccessor2<M, dyn ReflectRepeated> for MessageGetMut<M, RepeatedField<V>>
 where
     M: Message + 'static,
     V: ProtobufValue + 'static,
 {
-    fn get_field<'a>(&self, m: &'a M) -> &'a ReflectRepeated {
-        (self.get_field)(m) as &ReflectRepeated
+    fn get_field<'a>(&self, m: &'a M) -> &'a dyn ReflectRepeated {
+        (self.get_field)(m) as &dyn ReflectRepeated
     }
 
-    fn mut_field<'a>(&self, m: &'a mut M) -> &'a mut ReflectRepeated {
-        (self.mut_field)(m) as &mut ReflectRepeated
+    fn mut_field<'a>(&self, m: &'a mut M) -> &'a mut dyn ReflectRepeated {
+        (self.mut_field)(m) as &mut dyn ReflectRepeated
     }
 }
 
@@ -599,34 +595,31 @@
     name: &'static str,
     get_vec: for<'a> fn(&'a M) -> &'a RepeatedField<V::Value>,
     mut_vec: for<'a> fn(&'a mut M) -> &'a mut RepeatedField<V::Value>,
-) -> Box<FieldAccessor + 'static>
+) -> FieldAccessor
 where
     M: Message + 'static,
     V: ProtobufType + 'static,
 {
-    Box::new(FieldAccessorImpl {
-        name: name,
-        fns: FieldAccessorFunctions::Repeated(Box::new(MessageGetMut::<
-            M,
-            RepeatedField<V::Value>,
-        > {
+    FieldAccessor::new_v1(
+        name,
+        FieldAccessorFunctions::Repeated(Box::new(MessageGetMut::<M, RepeatedField<V::Value>> {
             get_field: get_vec,
             mut_field: mut_vec,
         })),
-    })
+    )
 }
 
-impl<M, V> FieldAccessor2<M, ReflectOptional> for MessageGetMut<M, Option<V>>
+impl<M, V> FieldAccessor2<M, dyn ReflectOptional> for MessageGetMut<M, Option<V>>
 where
     M: Message + 'static,
     V: ProtobufValue + Clone + 'static,
 {
-    fn get_field<'a>(&self, m: &'a M) -> &'a ReflectOptional {
-        (self.get_field)(m) as &ReflectOptional
+    fn get_field<'a>(&self, m: &'a M) -> &'a dyn ReflectOptional {
+        (self.get_field)(m) as &dyn ReflectOptional
     }
 
-    fn mut_field<'a>(&self, m: &'a mut M) -> &'a mut ReflectOptional {
-        (self.mut_field)(m) as &mut ReflectOptional
+    fn mut_field<'a>(&self, m: &'a mut M) -> &'a mut dyn ReflectOptional {
+        (self.mut_field)(m) as &mut dyn ReflectOptional
     }
 }
 
@@ -634,31 +627,31 @@
     name: &'static str,
     get_field: for<'a> fn(&'a M) -> &'a Option<V::Value>,
     mut_field: for<'a> fn(&'a mut M) -> &'a mut Option<V::Value>,
-) -> Box<FieldAccessor + 'static>
+) -> FieldAccessor
 where
     M: Message + 'static,
     V: ProtobufType + 'static,
 {
-    Box::new(FieldAccessorImpl {
-        name: name,
-        fns: FieldAccessorFunctions::Optional(Box::new(MessageGetMut::<M, Option<V::Value>> {
-            get_field: get_field,
-            mut_field: mut_field,
+    FieldAccessor::new_v1(
+        name,
+        FieldAccessorFunctions::Optional(Box::new(MessageGetMut::<M, Option<V::Value>> {
+            get_field,
+            mut_field,
         })),
-    })
+    )
 }
 
-impl<M, V> FieldAccessor2<M, ReflectOptional> for MessageGetMut<M, SingularField<V>>
+impl<M, V> FieldAccessor2<M, dyn ReflectOptional> for MessageGetMut<M, SingularField<V>>
 where
     M: Message + 'static,
     V: ProtobufValue + Clone + 'static,
 {
-    fn get_field<'a>(&self, m: &'a M) -> &'a ReflectOptional {
-        (self.get_field)(m) as &ReflectOptional
+    fn get_field<'a>(&self, m: &'a M) -> &'a dyn ReflectOptional {
+        (self.get_field)(m) as &dyn ReflectOptional
     }
 
-    fn mut_field<'a>(&self, m: &'a mut M) -> &'a mut ReflectOptional {
-        (self.mut_field)(m) as &mut ReflectOptional
+    fn mut_field<'a>(&self, m: &'a mut M) -> &'a mut dyn ReflectOptional {
+        (self.mut_field)(m) as &mut dyn ReflectOptional
     }
 }
 
@@ -666,34 +659,31 @@
     name: &'static str,
     get_field: for<'a> fn(&'a M) -> &'a SingularField<V::Value>,
     mut_field: for<'a> fn(&'a mut M) -> &'a mut SingularField<V::Value>,
-) -> Box<FieldAccessor + 'static>
+) -> FieldAccessor
 where
     M: Message + 'static,
     V: ProtobufType + 'static,
 {
-    Box::new(FieldAccessorImpl {
-        name: name,
-        fns: FieldAccessorFunctions::Optional(Box::new(MessageGetMut::<
-            M,
-            SingularField<V::Value>,
-        > {
-            get_field: get_field,
-            mut_field: mut_field,
+    FieldAccessor::new_v1(
+        name,
+        FieldAccessorFunctions::Optional(Box::new(MessageGetMut::<M, SingularField<V::Value>> {
+            get_field,
+            mut_field,
         })),
-    })
+    )
 }
 
-impl<M, V> FieldAccessor2<M, ReflectOptional> for MessageGetMut<M, SingularPtrField<V>>
+impl<M, V> FieldAccessor2<M, dyn ReflectOptional> for MessageGetMut<M, SingularPtrField<V>>
 where
     M: Message + 'static,
     V: ProtobufValue + Clone + 'static,
 {
-    fn get_field<'a>(&self, m: &'a M) -> &'a ReflectOptional {
-        (self.get_field)(m) as &ReflectOptional
+    fn get_field<'a>(&self, m: &'a M) -> &'a dyn ReflectOptional {
+        (self.get_field)(m) as &dyn ReflectOptional
     }
 
-    fn mut_field<'a>(&self, m: &'a mut M) -> &'a mut ReflectOptional {
-        (self.mut_field)(m) as &mut ReflectOptional
+    fn mut_field<'a>(&self, m: &'a mut M) -> &'a mut dyn ReflectOptional {
+        (self.mut_field)(m) as &mut dyn ReflectOptional
     }
 }
 
@@ -701,34 +691,33 @@
     name: &'static str,
     get_field: for<'a> fn(&'a M) -> &'a SingularPtrField<V::Value>,
     mut_field: for<'a> fn(&'a mut M) -> &'a mut SingularPtrField<V::Value>,
-) -> Box<FieldAccessor + 'static>
+) -> FieldAccessor
 where
     M: Message + 'static,
     V: ProtobufType + 'static,
 {
-    Box::new(FieldAccessorImpl {
-        name: name,
-        fns: FieldAccessorFunctions::Optional(Box::new(MessageGetMut::<
-            M,
-            SingularPtrField<V::Value>,
-        > {
-            get_field: get_field,
-            mut_field: mut_field,
-        })),
-    })
+    FieldAccessor::new_v1(
+        name,
+        FieldAccessorFunctions::Optional(Box::new(
+            MessageGetMut::<M, SingularPtrField<V::Value>> {
+                get_field,
+                mut_field,
+            },
+        )),
+    )
 }
 
-impl<M, V> FieldAccessor2<M, ProtobufValue> for MessageGetMut<M, V>
+impl<M, V> FieldAccessor2<M, dyn ProtobufValue> for MessageGetMut<M, V>
 where
     M: Message + 'static,
     V: ProtobufValue + Clone + 'static,
 {
-    fn get_field<'a>(&self, m: &'a M) -> &'a ProtobufValue {
-        (self.get_field)(m) as &ProtobufValue
+    fn get_field<'a>(&self, m: &'a M) -> &'a dyn ProtobufValue {
+        (self.get_field)(m) as &dyn ProtobufValue
     }
 
-    fn mut_field<'a>(&self, m: &'a mut M) -> &'a mut ProtobufValue {
-        (self.mut_field)(m) as &mut ProtobufValue
+    fn mut_field<'a>(&self, m: &'a mut M) -> &'a mut dyn ProtobufValue {
+        (self.mut_field)(m) as &mut dyn ProtobufValue
     }
 }
 
@@ -736,33 +725,33 @@
     name: &'static str,
     get_field: for<'a> fn(&'a M) -> &'a V::Value,
     mut_field: for<'a> fn(&'a mut M) -> &'a mut V::Value,
-) -> Box<FieldAccessor + 'static>
+) -> FieldAccessor
 where
     M: Message + 'static,
     V: ProtobufType + 'static,
 {
-    Box::new(FieldAccessorImpl {
-        name: name,
-        fns: FieldAccessorFunctions::Simple(Box::new(MessageGetMut::<M, V::Value> {
-            get_field: get_field,
-            mut_field: mut_field,
+    FieldAccessor::new_v1(
+        name,
+        FieldAccessorFunctions::Simple(Box::new(MessageGetMut::<M, V::Value> {
+            get_field,
+            mut_field,
         })),
-    })
+    )
 }
 
-impl<M, K, V> FieldAccessor2<M, ReflectMap> for MessageGetMut<M, HashMap<K, V>>
+impl<M, K, V> FieldAccessor2<M, dyn ReflectMap> for MessageGetMut<M, HashMap<K, V>>
 where
     M: Message + 'static,
     K: ProtobufValue + 'static,
     V: ProtobufValue + 'static,
     K: Hash + Eq,
 {
-    fn get_field<'a>(&self, m: &'a M) -> &'a ReflectMap {
-        (self.get_field)(m) as &ReflectMap
+    fn get_field<'a>(&self, m: &'a M) -> &'a dyn ReflectMap {
+        (self.get_field)(m) as &dyn ReflectMap
     }
 
-    fn mut_field<'a>(&self, m: &'a mut M) -> &'a mut ReflectMap {
-        (self.mut_field)(m) as &mut ReflectMap
+    fn mut_field<'a>(&self, m: &'a mut M) -> &'a mut dyn ReflectMap {
+        (self.mut_field)(m) as &mut dyn ReflectMap
     }
 }
 
@@ -770,20 +759,18 @@
     name: &'static str,
     get_field: for<'a> fn(&'a M) -> &'a HashMap<K::Value, V::Value>,
     mut_field: for<'a> fn(&'a mut M) -> &'a mut HashMap<K::Value, V::Value>,
-) -> Box<FieldAccessor + 'static>
+) -> FieldAccessor
 where
     M: Message + 'static,
     K: ProtobufType + 'static,
     V: ProtobufType + 'static,
     <K as ProtobufType>::Value: Hash + Eq,
 {
-    Box::new(FieldAccessorImpl {
-        name: name,
-        fns: FieldAccessorFunctions::Map(Box::new(
-            MessageGetMut::<M, HashMap<K::Value, V::Value>> {
-                get_field: get_field,
-                mut_field: mut_field,
-            },
-        )),
-    })
+    FieldAccessor::new_v1(
+        name,
+        FieldAccessorFunctions::Map(Box::new(MessageGetMut::<M, HashMap<K::Value, V::Value>> {
+            get_field,
+            mut_field,
+        })),
+    )
 }
diff --git a/src/reflect/accessor/mod.rs b/src/reflect/accessor/mod.rs
new file mode 100644
index 0000000..9fa97de
--- /dev/null
+++ b/src/reflect/accessor/mod.rs
@@ -0,0 +1,21 @@
+#![doc(hidden)]
+
+pub use crate::reflect::acc::v1::make_map_accessor;
+pub use crate::reflect::acc::v1::make_option_accessor;
+pub use crate::reflect::acc::v1::make_repeated_field_accessor;
+pub use crate::reflect::acc::v1::make_simple_field_accessor;
+pub use crate::reflect::acc::v1::make_singular_bool_accessor;
+pub use crate::reflect::acc::v1::make_singular_bytes_accessor;
+pub use crate::reflect::acc::v1::make_singular_enum_accessor;
+pub use crate::reflect::acc::v1::make_singular_f32_accessor;
+pub use crate::reflect::acc::v1::make_singular_f64_accessor;
+pub use crate::reflect::acc::v1::make_singular_field_accessor;
+pub use crate::reflect::acc::v1::make_singular_i32_accessor;
+pub use crate::reflect::acc::v1::make_singular_i64_accessor;
+pub use crate::reflect::acc::v1::make_singular_message_accessor;
+pub use crate::reflect::acc::v1::make_singular_ptr_field_accessor;
+pub use crate::reflect::acc::v1::make_singular_string_accessor;
+pub use crate::reflect::acc::v1::make_singular_u32_accessor;
+pub use crate::reflect::acc::v1::make_singular_u64_accessor;
+pub use crate::reflect::acc::v1::make_vec_accessor;
+pub use crate::reflect::acc::v1::FieldAccessorTrait;
diff --git a/src/reflect/enums.rs b/src/reflect/enums.rs
index e4ba4f6..f1ad901 100644
--- a/src/reflect/enums.rs
+++ b/src/reflect/enums.rs
@@ -1,11 +1,11 @@
-use descriptor::EnumDescriptorProto;
-use descriptor::EnumValueDescriptorProto;
-use descriptor::FileDescriptorProto;
-use descriptorx::find_enum_by_rust_name;
-use reflect::find_message_or_enum::find_message_or_enum;
-use reflect::find_message_or_enum::MessageOrEnum;
+use crate::descriptor::EnumDescriptorProto;
+use crate::descriptor::EnumValueDescriptorProto;
+use crate::descriptor::FileDescriptorProto;
+use crate::descriptorx::find_enum_by_rust_name;
+use crate::reflect::find_message_or_enum::find_message_or_enum;
+use crate::reflect::find_message_or_enum::MessageOrEnum;
+use crate::ProtobufEnum;
 use std::collections::HashMap;
-use ProtobufEnum;
 
 /// Description for enum variant.
 ///
diff --git a/src/reflect/field.rs b/src/reflect/field.rs
index ecac510..09ee222 100644
--- a/src/reflect/field.rs
+++ b/src/reflect/field.rs
@@ -1,9 +1,13 @@
-use descriptor::{FieldDescriptorProto, FieldDescriptorProto_Label};
-use reflect::accessor::FieldAccessor;
-use reflect::map::ReflectMap;
-use reflect::repeated::ReflectRepeated;
-use reflect::{EnumValueDescriptor, ReflectValueRef};
-use Message;
+use crate::descriptor::FieldDescriptorProto;
+use crate::descriptor::FieldDescriptorProto_Label;
+use crate::json::json_name;
+use crate::message::Message;
+use crate::reflect::acc::Accessor;
+use crate::reflect::acc::FieldAccessor;
+use crate::reflect::map::ReflectMap;
+use crate::reflect::repeated::ReflectRepeated;
+use crate::reflect::EnumValueDescriptor;
+use crate::reflect::ReflectValueRef;
 
 /// Reference to a value stored in a field, optional, repeated or map.
 // TODO: implement Eq
@@ -11,9 +15,9 @@
     /// Singular field, optional or required in proto3 and just plain field in proto3
     Optional(Option<ReflectValueRef<'a>>),
     /// Repeated field
-    Repeated(&'a ReflectRepeated),
+    Repeated(&'a dyn ReflectRepeated),
     /// Map field
-    Map(&'a ReflectMap),
+    Map(&'a dyn ReflectMap),
 }
 
 /// Field descriptor.
@@ -21,16 +25,27 @@
 /// Can be used for runtime reflection.
 pub struct FieldDescriptor {
     proto: &'static FieldDescriptorProto,
-    accessor: Box<FieldAccessor + 'static>,
+    accessor: FieldAccessor,
+    json_name: String,
 }
 
 impl FieldDescriptor {
     pub(crate) fn new(
-        accessor: Box<FieldAccessor + 'static>,
+        accessor: FieldAccessor,
         proto: &'static FieldDescriptorProto,
     ) -> FieldDescriptor {
-        assert_eq!(proto.get_name(), accessor.name_generic());
-        FieldDescriptor { proto, accessor }
+        assert_eq!(proto.get_name(), accessor.name);
+        let json_name = if !proto.get_json_name().is_empty() {
+            proto.get_json_name().to_string()
+        } else {
+            json_name(proto.get_name())
+        };
+        FieldDescriptor {
+            proto,
+            accessor,
+            // probably could be lazy-init
+            json_name,
+        }
     }
 
     /// Get `.proto` description of field
@@ -43,6 +58,17 @@
         self.proto.get_name()
     }
 
+    /// JSON field name.
+    ///
+    /// Can be different from `.proto` field name.
+    ///
+    /// See [JSON mapping][json] for details.
+    ///
+    /// [json]: https://developers.google.com/protocol-buffers/docs/proto3#json
+    pub fn json_name(&self) -> &str {
+        &self.json_name
+    }
+
     /// If this field repeated?
     pub fn is_repeated(&self) -> bool {
         self.proto.get_label() == FieldDescriptorProto_Label::LABEL_REPEATED
@@ -56,19 +82,23 @@
     /// # Panics
     ///
     /// If this field belongs to a different message type.
-    pub fn has_field(&self, m: &Message) -> bool {
-        self.accessor.has_field_generic(m)
+    pub fn has_field(&self, m: &dyn Message) -> bool {
+        match &self.accessor.accessor {
+            Accessor::V1(a) => a.has_field_generic(m),
+        }
     }
 
     /// Return length of repeated field.
     ///
-    /// For singualar field return `1` if field is set and `0` otherwise.
+    /// For singular field return `1` if field is set and `0` otherwise.
     ///
     /// # Panics
     ///
     /// If this field belongs to a different message type.
     pub fn len_field(&self, m: &dyn Message) -> usize {
-        self.accessor.len_field_generic(m)
+        match &self.accessor.accessor {
+            Accessor::V1(a) => a.len_field_generic(m),
+        }
     }
 
     /// Get message field or default instance if field is unset.
@@ -77,7 +107,9 @@
     /// If this field belongs to a different message type or
     /// field type is not message.
     pub fn get_message<'a>(&self, m: &'a dyn Message) -> &'a dyn Message {
-        self.accessor.get_message_generic(m)
+        match &self.accessor.accessor {
+            Accessor::V1(a) => a.get_message_generic(m),
+        }
     }
 
     /// Get `enum` field.
@@ -87,7 +119,9 @@
     /// If this field belongs to a different message type
     /// or field type is not singular `enum`.
     pub fn get_enum(&self, m: &dyn Message) -> &'static EnumValueDescriptor {
-        self.accessor.get_enum_generic(m)
+        match &self.accessor.accessor {
+            Accessor::V1(a) => a.get_enum_generic(m),
+        }
     }
 
     /// Get `string` field.
@@ -97,7 +131,9 @@
     /// If this field belongs to a different message type
     /// or field type is not singular `string`.
     pub fn get_str<'a>(&self, m: &'a dyn Message) -> &'a str {
-        self.accessor.get_str_generic(m)
+        match &self.accessor.accessor {
+            Accessor::V1(a) => a.get_str_generic(m),
+        }
     }
 
     /// Get `bytes` field.
@@ -107,7 +143,9 @@
     /// If this field belongs to a different message type
     /// or field type is not singular `bytes`.
     pub fn get_bytes<'a>(&self, m: &'a dyn Message) -> &'a [u8] {
-        self.accessor.get_bytes_generic(m)
+        match &self.accessor.accessor {
+            Accessor::V1(a) => a.get_bytes_generic(m),
+        }
     }
 
     /// Get `u32` field.
@@ -117,7 +155,9 @@
     /// If this field belongs to a different message type
     /// or field type is not singular `u32`.
     pub fn get_u32(&self, m: &dyn Message) -> u32 {
-        self.accessor.get_u32_generic(m)
+        match &self.accessor.accessor {
+            Accessor::V1(a) => a.get_u32_generic(m),
+        }
     }
 
     /// Get `u64` field.
@@ -127,7 +167,9 @@
     /// If this field belongs to a different message type
     /// or field type is not singular `u64`.
     pub fn get_u64(&self, m: &dyn Message) -> u64 {
-        self.accessor.get_u64_generic(m)
+        match &self.accessor.accessor {
+            Accessor::V1(a) => a.get_u64_generic(m),
+        }
     }
 
     /// Get `i32` field.
@@ -137,7 +179,9 @@
     /// If this field belongs to a different message type
     /// or field type is not singular `i32`.
     pub fn get_i32(&self, m: &dyn Message) -> i32 {
-        self.accessor.get_i32_generic(m)
+        match &self.accessor.accessor {
+            Accessor::V1(a) => a.get_i32_generic(m),
+        }
     }
 
     /// Get `i64` field.
@@ -147,7 +191,9 @@
     /// If this field belongs to a different message type
     /// or field type is not singular `i64`.
     pub fn get_i64(&self, m: &dyn Message) -> i64 {
-        self.accessor.get_i64_generic(m)
+        match &self.accessor.accessor {
+            Accessor::V1(a) => a.get_i64_generic(m),
+        }
     }
 
     /// Get `bool` field.
@@ -157,7 +203,9 @@
     /// If this field belongs to a different message type or
     /// field type is not singular `bool`.
     pub fn get_bool(&self, m: &dyn Message) -> bool {
-        self.accessor.get_bool_generic(m)
+        match &self.accessor.accessor {
+            Accessor::V1(a) => a.get_bool_generic(m),
+        }
     }
 
     /// Get `float` field.
@@ -167,7 +215,9 @@
     /// If this field belongs to a different message type or
     /// field type is not singular `float`.
     pub fn get_f32(&self, m: &dyn Message) -> f32 {
-        self.accessor.get_f32_generic(m)
+        match &self.accessor.accessor {
+            Accessor::V1(a) => a.get_f32_generic(m),
+        }
     }
 
     /// Get `double` field.
@@ -177,7 +227,9 @@
     /// If this field belongs to a different message type
     /// or field type is not singular `double`.
     pub fn get_f64(&self, m: &dyn Message) -> f64 {
-        self.accessor.get_f64_generic(m)
+        match &self.accessor.accessor {
+            Accessor::V1(a) => a.get_f64_generic(m),
+        }
     }
 
     /// Get field of any type.
@@ -186,6 +238,8 @@
     ///
     /// If this field belongs to a different message type.
     pub fn get_reflect<'a>(&self, m: &'a dyn Message) -> ReflectFieldRef<'a> {
-        self.accessor.get_reflect(m)
+        match &self.accessor.accessor {
+            Accessor::V1(a) => a.get_reflect(m),
+        }
     }
 }
diff --git a/src/reflect/message.rs b/src/reflect/message.rs
index c35a854..4730306 100644
--- a/src/reflect/message.rs
+++ b/src/reflect/message.rs
@@ -1,12 +1,12 @@
-use descriptor::{DescriptorProto, FileDescriptorProto};
-use descriptorx::find_message_by_rust_name;
-use reflect::accessor::FieldAccessor;
-use reflect::find_message_or_enum::find_message_or_enum;
-use reflect::find_message_or_enum::MessageOrEnum;
-use reflect::FieldDescriptor;
+use crate::descriptor::{DescriptorProto, FileDescriptorProto};
+use crate::descriptorx::find_message_by_rust_name;
+use crate::reflect::acc::FieldAccessor;
+use crate::reflect::find_message_or_enum::find_message_or_enum;
+use crate::reflect::find_message_or_enum::MessageOrEnum;
+use crate::reflect::FieldDescriptor;
+use crate::Message;
 use std::collections::HashMap;
 use std::marker;
-use Message;
 
 trait MessageFactory: Send + Sync + 'static {
     fn new_instance(&self) -> Box<dyn Message>;
@@ -32,6 +32,7 @@
     fields: Vec<FieldDescriptor>,
 
     index_by_name: HashMap<String, usize>,
+    index_by_name_or_json_name: HashMap<String, usize>,
     index_by_number: HashMap<u32, usize>,
 }
 
@@ -65,7 +66,7 @@
     // to reduce code bloat from multiple instantiations.
     fn new_non_generic_by_rust_name(
         rust_name: &'static str,
-        fields: Vec<Box<FieldAccessor + 'static>>,
+        fields: Vec<FieldAccessor>,
         file: &'static FileDescriptorProto,
         factory: &'static dyn MessageFactory,
     ) -> MessageDescriptor {
@@ -77,11 +78,8 @@
         }
 
         let mut index_by_name = HashMap::new();
+        let mut index_by_name_or_json_name = HashMap::new();
         let mut index_by_number = HashMap::new();
-        for (i, f) in proto.message.get_field().iter().enumerate() {
-            index_by_number.insert(f.get_number() as u32, i);
-            index_by_name.insert(f.get_name().to_string(), i);
-        }
 
         let mut full_name = file.get_package().to_string();
         if full_name.len() > 0 {
@@ -89,18 +87,37 @@
         }
         full_name.push_str(proto.message.get_name());
 
+        let fields: Vec<_> = fields
+            .into_iter()
+            .map(|f| {
+                let proto = *field_proto_by_name.get(&f.name).unwrap();
+                FieldDescriptor::new(f, proto)
+            })
+            .collect();
+        for (i, f) in fields.iter().enumerate() {
+            assert!(index_by_number
+                .insert(f.proto().get_number() as u32, i)
+                .is_none());
+            assert!(index_by_name
+                .insert(f.proto().get_name().to_owned(), i)
+                .is_none());
+            assert!(index_by_name_or_json_name
+                .insert(f.proto().get_name().to_owned(), i)
+                .is_none());
+
+            let json_name = f.json_name().to_owned();
+
+            if json_name != f.proto().get_name() {
+                assert!(index_by_name_or_json_name.insert(json_name, i).is_none());
+            }
+        }
         MessageDescriptor {
-            full_name: full_name,
+            full_name,
             proto: proto.message,
             factory,
-            fields: fields
-                .into_iter()
-                .map(|f| {
-                    let proto = *field_proto_by_name.get(&f.name_generic()).unwrap();
-                    FieldDescriptor::new(f, proto)
-                })
-                .collect(),
+            fields,
             index_by_name,
+            index_by_name_or_json_name,
             index_by_number,
         }
     }
@@ -109,7 +126,7 @@
     // to reduce code bloat from multiple instantiations.
     fn new_non_generic_by_pb_name(
         protobuf_name_to_package: &'static str,
-        fields: Vec<Box<FieldAccessor + 'static>>,
+        fields: Vec<FieldAccessor>,
         file_descriptor_proto: &'static FileDescriptorProto,
         factory: &'static dyn MessageFactory,
     ) -> MessageDescriptor {
@@ -125,28 +142,46 @@
         }
 
         let mut index_by_name = HashMap::new();
+        let mut index_by_name_or_json_name = HashMap::new();
         let mut index_by_number = HashMap::new();
-        for (i, f) in proto.get_field().iter().enumerate() {
-            index_by_number.insert(f.get_number() as u32, i);
-            index_by_name.insert(f.get_name().to_string(), i);
-        }
 
+        let full_name = MessageDescriptor::compute_full_name(
+            file_descriptor_proto.get_package(),
+            &path_to_package,
+            &proto,
+        );
+        let fields: Vec<_> = fields
+            .into_iter()
+            .map(|f| {
+                let proto = *field_proto_by_name.get(&f.name).unwrap();
+                FieldDescriptor::new(f, proto)
+            })
+            .collect();
+
+        for (i, f) in fields.iter().enumerate() {
+            assert!(index_by_number
+                .insert(f.proto().get_number() as u32, i)
+                .is_none());
+            assert!(index_by_name
+                .insert(f.proto().get_name().to_owned(), i)
+                .is_none());
+            assert!(index_by_name_or_json_name
+                .insert(f.proto().get_name().to_owned(), i)
+                .is_none());
+
+            let json_name = f.json_name().to_owned();
+
+            if json_name != f.proto().get_name() {
+                assert!(index_by_name_or_json_name.insert(json_name, i).is_none());
+            }
+        }
         MessageDescriptor {
-            full_name: MessageDescriptor::compute_full_name(
-                file_descriptor_proto.get_package(),
-                &path_to_package,
-                &proto,
-            ),
+            full_name,
             proto,
             factory,
-            fields: fields
-                .into_iter()
-                .map(|f| {
-                    let proto = *field_proto_by_name.get(&f.name_generic()).unwrap();
-                    FieldDescriptor::new(f, proto)
-                })
-                .collect(),
+            fields,
             index_by_name,
+            index_by_name_or_json_name,
             index_by_number,
         }
     }
@@ -162,7 +197,7 @@
     )]
     pub fn new<M: 'static + Message + Default + Clone + PartialEq>(
         rust_name: &'static str,
-        fields: Vec<Box<FieldAccessor + 'static>>,
+        fields: Vec<FieldAccessor>,
         file: &'static FileDescriptorProto,
     ) -> MessageDescriptor {
         let factory = &MessageFactoryImpl(marker::PhantomData::<M>);
@@ -176,7 +211,7 @@
     #[doc(hidden)]
     pub fn new_pb_name<M: 'static + Message + Default + Clone + PartialEq>(
         protobuf_name_to_package: &'static str,
-        fields: Vec<Box<FieldAccessor + 'static>>,
+        fields: Vec<FieldAccessor>,
         file_descriptor_proto: &'static FileDescriptorProto,
     ) -> MessageDescriptor {
         let factory = &MessageFactoryImpl(marker::PhantomData::<M>);
@@ -193,7 +228,7 @@
         self.factory.new_instance()
     }
 
-    /// Protobuf message name
+    /// Message name as given in `.proto` file
     pub fn name(&self) -> &'static str {
         self.proto.get_name()
     }
@@ -208,7 +243,28 @@
         &self.fields
     }
 
+    /// Find message field by protobuf field name
+    ///
+    /// Note: protobuf field name might be different for Rust field name.
+    pub fn get_field_by_name<'a>(&'a self, name: &str) -> Option<&'a FieldDescriptor> {
+        let &index = self.index_by_name.get(name)?;
+        Some(&self.fields[index])
+    }
+
+    /// Find message field by field name or field JSON name
+    pub fn get_field_by_name_or_json_name<'a>(&'a self, name: &str) -> Option<&'a FieldDescriptor> {
+        let &index = self.index_by_name_or_json_name.get(name)?;
+        Some(&self.fields[index])
+    }
+
+    /// Find message field by field name
+    pub fn get_field_by_number(&self, number: u32) -> Option<&FieldDescriptor> {
+        let &index = self.index_by_number.get(&number)?;
+        Some(&self.fields[index])
+    }
+
     /// Find field by name
+    // TODO: deprecate
     pub fn field_by_name<'a>(&'a self, name: &str) -> &'a FieldDescriptor {
         // TODO: clone is weird
         let &index = self.index_by_name.get(&name.to_string()).unwrap();
@@ -216,6 +272,7 @@
     }
 
     /// Find field by number
+    // TODO: deprecate
     pub fn field_by_number<'a>(&'a self, number: u32) -> &'a FieldDescriptor {
         let &index = self.index_by_number.get(&number).unwrap();
         &self.fields[index]
diff --git a/src/reflect/mod.rs b/src/reflect/mod.rs
index ede3743..392f629 100644
--- a/src/reflect/mod.rs
+++ b/src/reflect/mod.rs
@@ -1,7 +1,8 @@
 //! Reflection implementation for protobuf types.
 
-use core::Message;
+use crate::message::Message;
 
+mod acc;
 pub mod accessor;
 mod enums;
 mod field;
@@ -18,6 +19,8 @@
 #[deprecated(since = "2.11", note = "Use ReflectValueRef instead")]
 pub use self::value::ReflectValueRef as ProtobufValueRef;
 
+pub mod rt;
+
 pub use self::enums::EnumDescriptor;
 pub use self::enums::EnumValueDescriptor;
 
diff --git a/src/reflect/optional.rs b/src/reflect/optional.rs
index 4d33752..ba6cbaf 100644
--- a/src/reflect/optional.rs
+++ b/src/reflect/optional.rs
@@ -2,7 +2,7 @@
 
 use super::value::ProtobufValue;
 
-use singular::*;
+use crate::singular::*;
 
 pub trait ReflectOptional: 'static {
     fn to_option(&self) -> Option<&ProtobufValue>;
diff --git a/src/reflect/repeated.rs b/src/reflect/repeated.rs
index 7ffc979..43e265d 100644
--- a/src/reflect/repeated.rs
+++ b/src/reflect/repeated.rs
@@ -3,7 +3,7 @@
 use super::value::ProtobufValue;
 use super::value::ReflectValueRef;
 
-use repeated::RepeatedField;
+use crate::repeated::RepeatedField;
 
 pub trait ReflectRepeated: 'static {
     fn reflect_iter(&self) -> ReflectRepeatedIter;
diff --git a/src/reflect/rt/mod.rs b/src/reflect/rt/mod.rs
new file mode 100644
index 0000000..d715d92
--- /dev/null
+++ b/src/reflect/rt/mod.rs
@@ -0,0 +1,5 @@
+//! This module contains functions references for reflection in generated code.
+
+#![doc(hidden)]
+
+pub use crate::reflect::acc::FieldAccessor;
diff --git a/src/reflect/value.rs b/src/reflect/value.rs
index 22f76af..2671805 100644
--- a/src/reflect/value.rs
+++ b/src/reflect/value.rs
@@ -1,9 +1,9 @@
 use std::any::Any;
 
 #[cfg(feature = "bytes")]
-use bytes::Bytes;
+use crate::chars::Chars;
 #[cfg(feature = "bytes")]
-use chars::Chars;
+use bytes::Bytes;
 
 use super::*;
 
diff --git a/src/repeated.rs b/src/repeated.rs
index e5072cf..6ceae53 100644
--- a/src/repeated.rs
+++ b/src/repeated.rs
@@ -16,7 +16,7 @@
 use std::slice;
 use std::vec;
 
-use clear::Clear;
+use crate::clear::Clear;
 
 /// Wrapper around vector to avoid deallocations on clear.
 pub struct RepeatedField<T> {
@@ -207,6 +207,31 @@
         self.vec.remove(index)
     }
 
+    /// Retains only the elements specified by the predicate.
+    ///
+    /// In other words, remove all elements `e` such that `f(&e)` returns `false`.
+    /// This method operates in place, visiting each element exactly once in the
+    /// original order, and preserves the order of the retained elements.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use protobuf::RepeatedField;
+    ///
+    /// let mut vec = RepeatedField::from(vec![1, 2, 3, 4]);
+    /// vec.retain(|&x| x % 2 == 0);
+    /// assert_eq!(vec, RepeatedField::from(vec![2, 4]));
+    /// ```
+    pub fn retain<F>(&mut self, f: F)
+    where
+        F: FnMut(&T) -> bool,
+    {
+        // suboptimal
+        self.vec.truncate(self.len);
+        self.vec.retain(f);
+        self.len = self.vec.len();
+    }
+
     /// Truncate at specified length.
     #[inline]
     pub fn truncate(&mut self, len: usize) {
diff --git a/src/rt.rs b/src/rt.rs
index b50b71d..7af7c2c 100644
--- a/src/rt.rs
+++ b/src/rt.rs
@@ -6,31 +6,31 @@
 use std::hash::Hash;
 
 #[cfg(feature = "bytes")]
-use bytes::Bytes;
+use crate::chars::Chars;
 #[cfg(feature = "bytes")]
-use chars::Chars;
+use bytes::Bytes;
 
-use core::*;
-use enums::ProtobufEnum;
-use error::ProtobufError;
-use error::ProtobufResult;
-use error::WireError;
-use repeated::RepeatedField;
-use singular::SingularField;
-use singular::SingularPtrField;
-use stream::wire_format;
-use stream::wire_format::WireType;
-use stream::wire_format::WireTypeFixed32;
-use stream::wire_format::WireTypeFixed64;
-use stream::wire_format::WireTypeLengthDelimited;
-use stream::wire_format::WireTypeVarint;
-use stream::CodedInputStream;
-use stream::CodedOutputStream;
-use types::*;
-use zigzag::*;
+use crate::enums::ProtobufEnum;
+use crate::error::ProtobufError;
+use crate::error::ProtobufResult;
+use crate::error::WireError;
+use crate::message::*;
+use crate::repeated::RepeatedField;
+use crate::singular::SingularField;
+use crate::singular::SingularPtrField;
+use crate::stream::wire_format;
+use crate::stream::wire_format::WireType;
+use crate::stream::wire_format::WireTypeFixed32;
+use crate::stream::wire_format::WireTypeFixed64;
+use crate::stream::wire_format::WireTypeLengthDelimited;
+use crate::stream::wire_format::WireTypeVarint;
+use crate::stream::CodedInputStream;
+use crate::stream::CodedOutputStream;
+use crate::types::*;
+use crate::zigzag::*;
 
-use unknown::UnknownFields;
 pub use crate::lazy_v2::LazyV2;
+use crate::unknown::UnknownFields;
 
 /// Given `u64` value compute varint encoded length.
 pub fn compute_raw_varint64_size(value: u64) -> u32 {
diff --git a/src/rustproto.rs b/src/rustproto.rs
index 6690ee7..9b9a360 100644
--- a/src/rustproto.rs
+++ b/src/rustproto.rs
@@ -1,4 +1,4 @@
-// This file is generated by rust-protobuf 2.16.0-pre. Do not edit
+// This file is generated by rust-protobuf 2.17.0-pre. Do not edit
 // @generated
 
 // https://github.com/rust-lang/rust-clippy/issues/702
@@ -22,43 +22,43 @@
 /// Extension fields
 pub mod exts {
 
-    pub const expose_oneof_all: ::protobuf::ext::ExtFieldOptional<::protobuf::descriptor::FileOptions, ::protobuf::types::ProtobufTypeBool> = ::protobuf::ext::ExtFieldOptional { field_number: 17001, phantom: ::std::marker::PhantomData };
+    pub const expose_oneof_all: crate::ext::ExtFieldOptional<crate::descriptor::FileOptions, crate::types::ProtobufTypeBool> = crate::ext::ExtFieldOptional { field_number: 17001, phantom: ::std::marker::PhantomData };
 
-    pub const expose_fields_all: ::protobuf::ext::ExtFieldOptional<::protobuf::descriptor::FileOptions, ::protobuf::types::ProtobufTypeBool> = ::protobuf::ext::ExtFieldOptional { field_number: 17003, phantom: ::std::marker::PhantomData };
+    pub const expose_fields_all: crate::ext::ExtFieldOptional<crate::descriptor::FileOptions, crate::types::ProtobufTypeBool> = crate::ext::ExtFieldOptional { field_number: 17003, phantom: ::std::marker::PhantomData };
 
-    pub const generate_accessors_all: ::protobuf::ext::ExtFieldOptional<::protobuf::descriptor::FileOptions, ::protobuf::types::ProtobufTypeBool> = ::protobuf::ext::ExtFieldOptional { field_number: 17004, phantom: ::std::marker::PhantomData };
+    pub const generate_accessors_all: crate::ext::ExtFieldOptional<crate::descriptor::FileOptions, crate::types::ProtobufTypeBool> = crate::ext::ExtFieldOptional { field_number: 17004, phantom: ::std::marker::PhantomData };
 
-    pub const carllerche_bytes_for_bytes_all: ::protobuf::ext::ExtFieldOptional<::protobuf::descriptor::FileOptions, ::protobuf::types::ProtobufTypeBool> = ::protobuf::ext::ExtFieldOptional { field_number: 17011, phantom: ::std::marker::PhantomData };
+    pub const carllerche_bytes_for_bytes_all: crate::ext::ExtFieldOptional<crate::descriptor::FileOptions, crate::types::ProtobufTypeBool> = crate::ext::ExtFieldOptional { field_number: 17011, phantom: ::std::marker::PhantomData };
 
-    pub const carllerche_bytes_for_string_all: ::protobuf::ext::ExtFieldOptional<::protobuf::descriptor::FileOptions, ::protobuf::types::ProtobufTypeBool> = ::protobuf::ext::ExtFieldOptional { field_number: 17012, phantom: ::std::marker::PhantomData };
+    pub const carllerche_bytes_for_string_all: crate::ext::ExtFieldOptional<crate::descriptor::FileOptions, crate::types::ProtobufTypeBool> = crate::ext::ExtFieldOptional { field_number: 17012, phantom: ::std::marker::PhantomData };
 
-    pub const serde_derive_all: ::protobuf::ext::ExtFieldOptional<::protobuf::descriptor::FileOptions, ::protobuf::types::ProtobufTypeBool> = ::protobuf::ext::ExtFieldOptional { field_number: 17030, phantom: ::std::marker::PhantomData };
+    pub const serde_derive_all: crate::ext::ExtFieldOptional<crate::descriptor::FileOptions, crate::types::ProtobufTypeBool> = crate::ext::ExtFieldOptional { field_number: 17030, phantom: ::std::marker::PhantomData };
 
-    pub const serde_derive_cfg_all: ::protobuf::ext::ExtFieldOptional<::protobuf::descriptor::FileOptions, ::protobuf::types::ProtobufTypeString> = ::protobuf::ext::ExtFieldOptional { field_number: 17031, phantom: ::std::marker::PhantomData };
+    pub const serde_derive_cfg_all: crate::ext::ExtFieldOptional<crate::descriptor::FileOptions, crate::types::ProtobufTypeString> = crate::ext::ExtFieldOptional { field_number: 17031, phantom: ::std::marker::PhantomData };
 
-    pub const lite_runtime_all: ::protobuf::ext::ExtFieldOptional<::protobuf::descriptor::FileOptions, ::protobuf::types::ProtobufTypeBool> = ::protobuf::ext::ExtFieldOptional { field_number: 17035, phantom: ::std::marker::PhantomData };
+    pub const lite_runtime_all: crate::ext::ExtFieldOptional<crate::descriptor::FileOptions, crate::types::ProtobufTypeBool> = crate::ext::ExtFieldOptional { field_number: 17035, phantom: ::std::marker::PhantomData };
 
-    pub const expose_oneof: ::protobuf::ext::ExtFieldOptional<::protobuf::descriptor::MessageOptions, ::protobuf::types::ProtobufTypeBool> = ::protobuf::ext::ExtFieldOptional { field_number: 17001, phantom: ::std::marker::PhantomData };
+    pub const expose_oneof: crate::ext::ExtFieldOptional<crate::descriptor::MessageOptions, crate::types::ProtobufTypeBool> = crate::ext::ExtFieldOptional { field_number: 17001, phantom: ::std::marker::PhantomData };
 
-    pub const expose_fields: ::protobuf::ext::ExtFieldOptional<::protobuf::descriptor::MessageOptions, ::protobuf::types::ProtobufTypeBool> = ::protobuf::ext::ExtFieldOptional { field_number: 17003, phantom: ::std::marker::PhantomData };
+    pub const expose_fields: crate::ext::ExtFieldOptional<crate::descriptor::MessageOptions, crate::types::ProtobufTypeBool> = crate::ext::ExtFieldOptional { field_number: 17003, phantom: ::std::marker::PhantomData };
 
-    pub const generate_accessors: ::protobuf::ext::ExtFieldOptional<::protobuf::descriptor::MessageOptions, ::protobuf::types::ProtobufTypeBool> = ::protobuf::ext::ExtFieldOptional { field_number: 17004, phantom: ::std::marker::PhantomData };
+    pub const generate_accessors: crate::ext::ExtFieldOptional<crate::descriptor::MessageOptions, crate::types::ProtobufTypeBool> = crate::ext::ExtFieldOptional { field_number: 17004, phantom: ::std::marker::PhantomData };
 
-    pub const carllerche_bytes_for_bytes: ::protobuf::ext::ExtFieldOptional<::protobuf::descriptor::MessageOptions, ::protobuf::types::ProtobufTypeBool> = ::protobuf::ext::ExtFieldOptional { field_number: 17011, phantom: ::std::marker::PhantomData };
+    pub const carllerche_bytes_for_bytes: crate::ext::ExtFieldOptional<crate::descriptor::MessageOptions, crate::types::ProtobufTypeBool> = crate::ext::ExtFieldOptional { field_number: 17011, phantom: ::std::marker::PhantomData };
 
-    pub const carllerche_bytes_for_string: ::protobuf::ext::ExtFieldOptional<::protobuf::descriptor::MessageOptions, ::protobuf::types::ProtobufTypeBool> = ::protobuf::ext::ExtFieldOptional { field_number: 17012, phantom: ::std::marker::PhantomData };
+    pub const carllerche_bytes_for_string: crate::ext::ExtFieldOptional<crate::descriptor::MessageOptions, crate::types::ProtobufTypeBool> = crate::ext::ExtFieldOptional { field_number: 17012, phantom: ::std::marker::PhantomData };
 
-    pub const serde_derive: ::protobuf::ext::ExtFieldOptional<::protobuf::descriptor::MessageOptions, ::protobuf::types::ProtobufTypeBool> = ::protobuf::ext::ExtFieldOptional { field_number: 17030, phantom: ::std::marker::PhantomData };
+    pub const serde_derive: crate::ext::ExtFieldOptional<crate::descriptor::MessageOptions, crate::types::ProtobufTypeBool> = crate::ext::ExtFieldOptional { field_number: 17030, phantom: ::std::marker::PhantomData };
 
-    pub const serde_derive_cfg: ::protobuf::ext::ExtFieldOptional<::protobuf::descriptor::MessageOptions, ::protobuf::types::ProtobufTypeString> = ::protobuf::ext::ExtFieldOptional { field_number: 17031, phantom: ::std::marker::PhantomData };
+    pub const serde_derive_cfg: crate::ext::ExtFieldOptional<crate::descriptor::MessageOptions, crate::types::ProtobufTypeString> = crate::ext::ExtFieldOptional { field_number: 17031, phantom: ::std::marker::PhantomData };
 
-    pub const expose_fields_field: ::protobuf::ext::ExtFieldOptional<::protobuf::descriptor::FieldOptions, ::protobuf::types::ProtobufTypeBool> = ::protobuf::ext::ExtFieldOptional { field_number: 17003, phantom: ::std::marker::PhantomData };
+    pub const expose_fields_field: crate::ext::ExtFieldOptional<crate::descriptor::FieldOptions, crate::types::ProtobufTypeBool> = crate::ext::ExtFieldOptional { field_number: 17003, phantom: ::std::marker::PhantomData };
 
-    pub const generate_accessors_field: ::protobuf::ext::ExtFieldOptional<::protobuf::descriptor::FieldOptions, ::protobuf::types::ProtobufTypeBool> = ::protobuf::ext::ExtFieldOptional { field_number: 17004, phantom: ::std::marker::PhantomData };
+    pub const generate_accessors_field: crate::ext::ExtFieldOptional<crate::descriptor::FieldOptions, crate::types::ProtobufTypeBool> = crate::ext::ExtFieldOptional { field_number: 17004, phantom: ::std::marker::PhantomData };
 
-    pub const carllerche_bytes_for_bytes_field: ::protobuf::ext::ExtFieldOptional<::protobuf::descriptor::FieldOptions, ::protobuf::types::ProtobufTypeBool> = ::protobuf::ext::ExtFieldOptional { field_number: 17011, phantom: ::std::marker::PhantomData };
+    pub const carllerche_bytes_for_bytes_field: crate::ext::ExtFieldOptional<crate::descriptor::FieldOptions, crate::types::ProtobufTypeBool> = crate::ext::ExtFieldOptional { field_number: 17011, phantom: ::std::marker::PhantomData };
 
-    pub const carllerche_bytes_for_string_field: ::protobuf::ext::ExtFieldOptional<::protobuf::descriptor::FieldOptions, ::protobuf::types::ProtobufTypeBool> = ::protobuf::ext::ExtFieldOptional { field_number: 17012, phantom: ::std::marker::PhantomData };
+    pub const carllerche_bytes_for_string_field: crate::ext::ExtFieldOptional<crate::descriptor::FieldOptions, crate::types::ProtobufTypeBool> = crate::ext::ExtFieldOptional { field_number: 17012, phantom: ::std::marker::PhantomData };
 }
 
 static file_descriptor_proto_data: &'static [u8] = b"\
@@ -182,13 +182,13 @@
     \n\x03\x07\x12\x03\x12\x0366;\
 ";
 
-static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;
+static file_descriptor_proto_lazy: crate::rt::LazyV2<crate::descriptor::FileDescriptorProto> = crate::rt::LazyV2::INIT;
 
-fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
-    ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap()
+fn parse_descriptor_proto() -> crate::descriptor::FileDescriptorProto {
+    crate::parse_from_bytes(file_descriptor_proto_data).unwrap()
 }
 
-pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
+pub fn file_descriptor_proto() -> &'static crate::descriptor::FileDescriptorProto {
     file_descriptor_proto_lazy.get(|| {
         parse_descriptor_proto()
     })
diff --git a/src/singular.rs b/src/singular.rs
index 71d4f0a..ef04d2f 100644
--- a/src/singular.rs
+++ b/src/singular.rs
@@ -8,7 +8,7 @@
 use std::mem;
 use std::option;
 
-use clear::Clear;
+use crate::clear::Clear;
 
 /// Like `Option<T>`, but keeps the actual element on `clear`.
 pub struct SingularField<T> {
@@ -552,7 +552,7 @@
 #[cfg(test)]
 mod test {
     use super::SingularField;
-    use clear::Clear;
+    use crate::clear::Clear;
 
     #[test]
     fn test_set_default_clears() {
diff --git a/src/stream.rs b/src/stream.rs
index 074d9c7..d503fd7 100644
--- a/src/stream.rs
+++ b/src/stream.rs
@@ -9,26 +9,26 @@
 use std::slice;
 
 #[cfg(feature = "bytes")]
-use bytes::Bytes;
+use crate::chars::Chars;
 #[cfg(feature = "bytes")]
-use chars::Chars;
+use bytes::Bytes;
 
-use buf_read_iter::BufReadIter;
-use core::Message;
-use enums::ProtobufEnum;
-use error::ProtobufError;
-use error::ProtobufResult;
-use error::WireError;
-use misc::remaining_capacity_as_slice_mut;
-use misc::remove_lifetime_mut;
-use unknown::UnknownFields;
-use unknown::UnknownValue;
-use unknown::UnknownValueRef;
-use varint;
-use zigzag::decode_zig_zag_32;
-use zigzag::decode_zig_zag_64;
-use zigzag::encode_zig_zag_32;
-use zigzag::encode_zig_zag_64;
+use crate::buf_read_iter::BufReadIter;
+use crate::enums::ProtobufEnum;
+use crate::error::ProtobufError;
+use crate::error::ProtobufResult;
+use crate::error::WireError;
+use crate::message::Message;
+use crate::misc::remaining_capacity_as_slice_mut;
+use crate::misc::remove_lifetime_mut;
+use crate::unknown::UnknownFields;
+use crate::unknown::UnknownValue;
+use crate::unknown::UnknownValueRef;
+use crate::varint;
+use crate::zigzag::decode_zig_zag_32;
+use crate::zigzag::decode_zig_zag_64;
+use crate::zigzag::encode_zig_zag_32;
+use crate::zigzag::encode_zig_zag_64;
 
 /// Equal to the default buffer size of `BufWriter`, so when
 /// `CodedOutputStream` wraps `BufWriter`, it often skips double buffering.
@@ -1427,10 +1427,10 @@
     use std::io::Write;
     use std::iter::repeat;
 
-    use error::ProtobufError;
-    use error::ProtobufResult;
-    use hex::decode_hex;
-    use hex::encode_hex;
+    use crate::error::ProtobufError;
+    use crate::error::ProtobufResult;
+    use crate::hex::decode_hex;
+    use crate::hex::encode_hex;
 
     use super::wire_format;
     use super::CodedInputStream;
diff --git a/src/text_format.rs b/src/text_format.rs
index 7ba3721..59bd07a 100644
--- a/src/text_format.rs
+++ b/src/text_format.rs
@@ -19,9 +19,9 @@
 //! protobuf implementations, including `protoc` command which can decode
 //! and encode messages using text format.
 
-use core::Message;
-use reflect::ReflectFieldRef;
-use reflect::ReflectValueRef;
+use crate::message::Message;
+use crate::reflect::ReflectFieldRef;
+use crate::reflect::ReflectValueRef;
 use std;
 use std::fmt;
 use std::fmt::Write;
diff --git a/src/types.rs b/src/types.rs
index 2c3863a..2308dee 100644
--- a/src/types.rs
+++ b/src/types.rs
@@ -4,22 +4,22 @@
 use std::mem;
 
 #[cfg(feature = "bytes")]
-use bytes::Bytes;
+use crate::chars::Chars;
 #[cfg(feature = "bytes")]
-use chars::Chars;
+use bytes::Bytes;
 
-use core::Message;
-use enums::ProtobufEnum;
-use error::ProtobufResult;
-use parse_from_bytes;
-use reflect::ProtobufValue;
-use rt;
-use stream::CodedInputStream;
-use stream::CodedOutputStream;
-use unknown::UnknownValues;
-use wire_format::WireType;
-use zigzag::decode_zig_zag_32;
-use zigzag::decode_zig_zag_64;
+use crate::enums::ProtobufEnum;
+use crate::error::ProtobufResult;
+use crate::message::Message;
+use crate::parse_from_bytes;
+use crate::reflect::ProtobufValue;
+use crate::rt;
+use crate::stream::CodedInputStream;
+use crate::stream::CodedOutputStream;
+use crate::unknown::UnknownValues;
+use crate::wire_format::WireType;
+use crate::zigzag::decode_zig_zag_32;
+use crate::zigzag::decode_zig_zag_64;
 
 /// Protobuf elementary type as generic trait
 pub trait ProtobufType {
diff --git a/src/unknown.rs b/src/unknown.rs
index 2ab9a94..514379c 100644
--- a/src/unknown.rs
+++ b/src/unknown.rs
@@ -1,4 +1,7 @@
-use clear::Clear;
+use crate::clear::Clear;
+use crate::stream::wire_format;
+use crate::zigzag::encode_zig_zag_32;
+use crate::zigzag::encode_zig_zag_64;
 use std::collections::hash_map;
 use std::collections::hash_map::DefaultHasher;
 use std::collections::HashMap;
@@ -6,9 +9,6 @@
 use std::hash::Hash;
 use std::hash::Hasher;
 use std::slice;
-use stream::wire_format;
-use zigzag::encode_zig_zag_32;
-use zigzag::encode_zig_zag_64;
 
 /// Unknown value.
 ///
diff --git a/src/well_known_types/any.rs b/src/well_known_types/any.rs
index 71ee88d..a2a2c1e 100644
--- a/src/well_known_types/any.rs
+++ b/src/well_known_types/any.rs
@@ -1,4 +1,4 @@
-// This file is generated by rust-protobuf 2.16.0-pre. Do not edit
+// This file is generated by rust-protobuf 2.17.0-pre. Do not edit
 // @generated
 
 // https://github.com/rust-lang/rust-clippy/issues/702
@@ -27,14 +27,14 @@
     pub value: ::std::vec::Vec<u8>,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a Any {
     fn default() -> &'a Any {
-        <Any as ::protobuf::Message>::default_instance()
+        <Any as crate::Message>::default_instance()
     }
 }
 
@@ -96,23 +96,23 @@
     }
 }
 
-impl ::protobuf::Message for Any {
+impl crate::Message for Any {
     fn is_initialized(&self) -> bool {
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::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.type_url)?;
+                    crate::rt::read_singular_proto3_string_into(wire_type, is, &mut self.type_url)?;
                 },
                 2 => {
-                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.value)?;
+                    crate::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.value)?;
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -124,17 +124,17 @@
     fn compute_size(&self) -> u32 {
         let mut my_size = 0;
         if !self.type_url.is_empty() {
-            my_size += ::protobuf::rt::string_size(1, &self.type_url);
+            my_size += crate::rt::string_size(1, &self.type_url);
         }
         if !self.value.is_empty() {
-            my_size += ::protobuf::rt::bytes_size(2, &self.value);
+            my_size += crate::rt::bytes_size(2, &self.value);
         }
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         if !self.type_url.is_empty() {
             os.write_string(1, &self.type_url)?;
         }
@@ -149,11 +149,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -167,7 +167,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -175,21 +175,21 @@
         Any::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "type_url",
                 |m: &Any| { &m.type_url },
                 |m: &mut Any| { &mut m.type_url },
             ));
-            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
+            fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeBytes>(
                 "value",
                 |m: &Any| { &m.value },
                 |m: &mut Any| { &mut m.value },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Any>(
+            crate::reflect::MessageDescriptor::new_pb_name::<Any>(
                 "Any",
                 fields,
                 file_descriptor_proto()
@@ -198,12 +198,12 @@
     }
 
     fn default_instance() -> &'static Any {
-        static instance: ::protobuf::rt::LazyV2<Any> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<Any> = crate::rt::LazyV2::INIT;
         instance.get(Any::new)
     }
 }
 
-impl ::protobuf::Clear for Any {
+impl crate::Clear for Any {
     fn clear(&mut self) {
         self.type_url.clear();
         self.value.clear();
@@ -213,13 +213,13 @@
 
 impl ::std::fmt::Debug for Any {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for Any {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for Any {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -346,13 +346,13 @@
     \x10\x11b\x06proto3\
 ";
 
-static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;
+static file_descriptor_proto_lazy: crate::rt::LazyV2<crate::descriptor::FileDescriptorProto> = crate::rt::LazyV2::INIT;
 
-fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
-    ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap()
+fn parse_descriptor_proto() -> crate::descriptor::FileDescriptorProto {
+    crate::parse_from_bytes(file_descriptor_proto_data).unwrap()
 }
 
-pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
+pub fn file_descriptor_proto() -> &'static crate::descriptor::FileDescriptorProto {
     file_descriptor_proto_lazy.get(|| {
         parse_descriptor_proto()
     })
diff --git a/src/well_known_types/api.rs b/src/well_known_types/api.rs
index 5742a7d..188f4b3 100644
--- a/src/well_known_types/api.rs
+++ b/src/well_known_types/api.rs
@@ -1,4 +1,4 @@
-// This file is generated by rust-protobuf 2.16.0-pre. Do not edit
+// This file is generated by rust-protobuf 2.17.0-pre. Do not edit
 // @generated
 
 // https://github.com/rust-lang/rust-clippy/issues/702
@@ -24,22 +24,22 @@
 pub struct Api {
     // message fields
     pub name: ::std::string::String,
-    pub methods: ::protobuf::RepeatedField<Method>,
-    pub options: ::protobuf::RepeatedField<::protobuf::well_known_types::Option>,
+    pub methods: crate::RepeatedField<Method>,
+    pub options: crate::RepeatedField<crate::well_known_types::Option>,
     pub version: ::std::string::String,
-    pub source_context: ::protobuf::SingularPtrField<::protobuf::well_known_types::SourceContext>,
-    pub mixins: ::protobuf::RepeatedField<Mixin>,
-    pub syntax: ::protobuf::well_known_types::Syntax,
+    pub source_context: crate::SingularPtrField<crate::well_known_types::SourceContext>,
+    pub mixins: crate::RepeatedField<Mixin>,
+    pub syntax: crate::well_known_types::Syntax,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a Api {
     fn default() -> &'a Api {
-        <Api as ::protobuf::Message>::default_instance()
+        <Api as crate::Message>::default_instance()
     }
 }
 
@@ -85,24 +85,24 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_methods(&mut self, v: ::protobuf::RepeatedField<Method>) {
+    pub fn set_methods(&mut self, v: crate::RepeatedField<Method>) {
         self.methods = v;
     }
 
     // Mutable pointer to the field.
-    pub fn mut_methods(&mut self) -> &mut ::protobuf::RepeatedField<Method> {
+    pub fn mut_methods(&mut self) -> &mut crate::RepeatedField<Method> {
         &mut self.methods
     }
 
     // Take field
-    pub fn take_methods(&mut self) -> ::protobuf::RepeatedField<Method> {
-        ::std::mem::replace(&mut self.methods, ::protobuf::RepeatedField::new())
+    pub fn take_methods(&mut self) -> crate::RepeatedField<Method> {
+        ::std::mem::replace(&mut self.methods, crate::RepeatedField::new())
     }
 
     // repeated .google.protobuf.Option options = 3;
 
 
-    pub fn get_options(&self) -> &[::protobuf::well_known_types::Option] {
+    pub fn get_options(&self) -> &[crate::well_known_types::Option] {
         &self.options
     }
     pub fn clear_options(&mut self) {
@@ -110,18 +110,18 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_options(&mut self, v: ::protobuf::RepeatedField<::protobuf::well_known_types::Option>) {
+    pub fn set_options(&mut self, v: crate::RepeatedField<crate::well_known_types::Option>) {
         self.options = v;
     }
 
     // Mutable pointer to the field.
-    pub fn mut_options(&mut self) -> &mut ::protobuf::RepeatedField<::protobuf::well_known_types::Option> {
+    pub fn mut_options(&mut self) -> &mut crate::RepeatedField<crate::well_known_types::Option> {
         &mut self.options
     }
 
     // Take field
-    pub fn take_options(&mut self) -> ::protobuf::RepeatedField<::protobuf::well_known_types::Option> {
-        ::std::mem::replace(&mut self.options, ::protobuf::RepeatedField::new())
+    pub fn take_options(&mut self) -> crate::RepeatedField<crate::well_known_types::Option> {
+        ::std::mem::replace(&mut self.options, crate::RepeatedField::new())
     }
 
     // string version = 4;
@@ -153,8 +153,8 @@
     // .google.protobuf.SourceContext source_context = 5;
 
 
-    pub fn get_source_context(&self) -> &::protobuf::well_known_types::SourceContext {
-        self.source_context.as_ref().unwrap_or_else(|| <::protobuf::well_known_types::SourceContext as ::protobuf::Message>::default_instance())
+    pub fn get_source_context(&self) -> &crate::well_known_types::SourceContext {
+        self.source_context.as_ref().unwrap_or_else(|| <crate::well_known_types::SourceContext as crate::Message>::default_instance())
     }
     pub fn clear_source_context(&mut self) {
         self.source_context.clear();
@@ -165,13 +165,13 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_source_context(&mut self, v: ::protobuf::well_known_types::SourceContext) {
-        self.source_context = ::protobuf::SingularPtrField::some(v);
+    pub fn set_source_context(&mut self, v: crate::well_known_types::SourceContext) {
+        self.source_context = crate::SingularPtrField::some(v);
     }
 
     // Mutable pointer to the field.
     // If field is not initialized, it is initialized with default value first.
-    pub fn mut_source_context(&mut self) -> &mut ::protobuf::well_known_types::SourceContext {
+    pub fn mut_source_context(&mut self) -> &mut crate::well_known_types::SourceContext {
         if self.source_context.is_none() {
             self.source_context.set_default();
         }
@@ -179,8 +179,8 @@
     }
 
     // Take field
-    pub fn take_source_context(&mut self) -> ::protobuf::well_known_types::SourceContext {
-        self.source_context.take().unwrap_or_else(|| ::protobuf::well_known_types::SourceContext::new())
+    pub fn take_source_context(&mut self) -> crate::well_known_types::SourceContext {
+        self.source_context.take().unwrap_or_else(|| crate::well_known_types::SourceContext::new())
     }
 
     // repeated .google.protobuf.Mixin mixins = 6;
@@ -194,37 +194,37 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_mixins(&mut self, v: ::protobuf::RepeatedField<Mixin>) {
+    pub fn set_mixins(&mut self, v: crate::RepeatedField<Mixin>) {
         self.mixins = v;
     }
 
     // Mutable pointer to the field.
-    pub fn mut_mixins(&mut self) -> &mut ::protobuf::RepeatedField<Mixin> {
+    pub fn mut_mixins(&mut self) -> &mut crate::RepeatedField<Mixin> {
         &mut self.mixins
     }
 
     // Take field
-    pub fn take_mixins(&mut self) -> ::protobuf::RepeatedField<Mixin> {
-        ::std::mem::replace(&mut self.mixins, ::protobuf::RepeatedField::new())
+    pub fn take_mixins(&mut self) -> crate::RepeatedField<Mixin> {
+        ::std::mem::replace(&mut self.mixins, crate::RepeatedField::new())
     }
 
     // .google.protobuf.Syntax syntax = 7;
 
 
-    pub fn get_syntax(&self) -> ::protobuf::well_known_types::Syntax {
+    pub fn get_syntax(&self) -> crate::well_known_types::Syntax {
         self.syntax
     }
     pub fn clear_syntax(&mut self) {
-        self.syntax = ::protobuf::well_known_types::Syntax::SYNTAX_PROTO2;
+        self.syntax = crate::well_known_types::Syntax::SYNTAX_PROTO2;
     }
 
     // Param is passed by value, moved
-    pub fn set_syntax(&mut self, v: ::protobuf::well_known_types::Syntax) {
+    pub fn set_syntax(&mut self, v: crate::well_known_types::Syntax) {
         self.syntax = v;
     }
 }
 
-impl ::protobuf::Message for Api {
+impl crate::Message for Api {
     fn is_initialized(&self) -> bool {
         for v in &self.methods {
             if !v.is_initialized() {
@@ -249,33 +249,33 @@
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::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.name)?;
+                    crate::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
                 },
                 2 => {
-                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.methods)?;
+                    crate::rt::read_repeated_message_into(wire_type, is, &mut self.methods)?;
                 },
                 3 => {
-                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.options)?;
+                    crate::rt::read_repeated_message_into(wire_type, is, &mut self.options)?;
                 },
                 4 => {
-                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.version)?;
+                    crate::rt::read_singular_proto3_string_into(wire_type, is, &mut self.version)?;
                 },
                 5 => {
-                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.source_context)?;
+                    crate::rt::read_singular_message_into(wire_type, is, &mut self.source_context)?;
                 },
                 6 => {
-                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.mixins)?;
+                    crate::rt::read_repeated_message_into(wire_type, is, &mut self.mixins)?;
                 },
                 7 => {
-                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.syntax, 7, &mut self.unknown_fields)?
+                    crate::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.syntax, 7, &mut self.unknown_fields)?
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -287,46 +287,46 @@
     fn compute_size(&self) -> u32 {
         let mut my_size = 0;
         if !self.name.is_empty() {
-            my_size += ::protobuf::rt::string_size(1, &self.name);
+            my_size += crate::rt::string_size(1, &self.name);
         }
         for value in &self.methods {
             let len = value.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
         };
         for value in &self.options {
             let len = value.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
         };
         if !self.version.is_empty() {
-            my_size += ::protobuf::rt::string_size(4, &self.version);
+            my_size += crate::rt::string_size(4, &self.version);
         }
         if let Some(ref v) = self.source_context.as_ref() {
             let len = v.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
         }
         for value in &self.mixins {
             let len = value.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
         };
-        if self.syntax != ::protobuf::well_known_types::Syntax::SYNTAX_PROTO2 {
-            my_size += ::protobuf::rt::enum_size(7, self.syntax);
+        if self.syntax != crate::well_known_types::Syntax::SYNTAX_PROTO2 {
+            my_size += crate::rt::enum_size(7, self.syntax);
         }
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         if !self.name.is_empty() {
             os.write_string(1, &self.name)?;
         }
         for v in &self.methods {
-            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(2, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         };
         for v in &self.options {
-            os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(3, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         };
@@ -334,17 +334,17 @@
             os.write_string(4, &self.version)?;
         }
         if let Some(ref v) = self.source_context.as_ref() {
-            os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(5, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         }
         for v in &self.mixins {
-            os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(6, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         };
-        if self.syntax != ::protobuf::well_known_types::Syntax::SYNTAX_PROTO2 {
-            os.write_enum(7, ::protobuf::ProtobufEnum::value(&self.syntax))?;
+        if self.syntax != crate::well_known_types::Syntax::SYNTAX_PROTO2 {
+            os.write_enum(7, crate::ProtobufEnum::value(&self.syntax))?;
         }
         os.write_unknown_fields(self.get_unknown_fields())?;
         ::std::result::Result::Ok(())
@@ -354,11 +354,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -372,7 +372,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -380,46 +380,46 @@
         Api::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "name",
                 |m: &Api| { &m.name },
                 |m: &mut Api| { &mut m.name },
             ));
-            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Method>>(
+            fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<Method>>(
                 "methods",
                 |m: &Api| { &m.methods },
                 |m: &mut Api| { &mut m.methods },
             ));
-            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Option>>(
+            fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<crate::well_known_types::Option>>(
                 "options",
                 |m: &Api| { &m.options },
                 |m: &mut Api| { &mut m.options },
             ));
-            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "version",
                 |m: &Api| { &m.version },
                 |m: &mut Api| { &mut m.version },
             ));
-            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::SourceContext>>(
+            fields.push(crate::reflect::accessor::make_singular_ptr_field_accessor::<_, crate::types::ProtobufTypeMessage<crate::well_known_types::SourceContext>>(
                 "source_context",
                 |m: &Api| { &m.source_context },
                 |m: &mut Api| { &mut m.source_context },
             ));
-            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Mixin>>(
+            fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<Mixin>>(
                 "mixins",
                 |m: &Api| { &m.mixins },
                 |m: &mut Api| { &mut m.mixins },
             ));
-            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<::protobuf::well_known_types::Syntax>>(
+            fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeEnum<crate::well_known_types::Syntax>>(
                 "syntax",
                 |m: &Api| { &m.syntax },
                 |m: &mut Api| { &mut m.syntax },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Api>(
+            crate::reflect::MessageDescriptor::new_pb_name::<Api>(
                 "Api",
                 fields,
                 file_descriptor_proto()
@@ -428,12 +428,12 @@
     }
 
     fn default_instance() -> &'static Api {
-        static instance: ::protobuf::rt::LazyV2<Api> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<Api> = crate::rt::LazyV2::INIT;
         instance.get(Api::new)
     }
 }
 
-impl ::protobuf::Clear for Api {
+impl crate::Clear for Api {
     fn clear(&mut self) {
         self.name.clear();
         self.methods.clear();
@@ -441,20 +441,20 @@
         self.version.clear();
         self.source_context.clear();
         self.mixins.clear();
-        self.syntax = ::protobuf::well_known_types::Syntax::SYNTAX_PROTO2;
+        self.syntax = crate::well_known_types::Syntax::SYNTAX_PROTO2;
         self.unknown_fields.clear();
     }
 }
 
 impl ::std::fmt::Debug for Api {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for Api {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for Api {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -467,18 +467,18 @@
     pub request_streaming: bool,
     pub response_type_url: ::std::string::String,
     pub response_streaming: bool,
-    pub options: ::protobuf::RepeatedField<::protobuf::well_known_types::Option>,
-    pub syntax: ::protobuf::well_known_types::Syntax,
+    pub options: crate::RepeatedField<crate::well_known_types::Option>,
+    pub syntax: crate::well_known_types::Syntax,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a Method {
     fn default() -> &'a Method {
-        <Method as ::protobuf::Message>::default_instance()
+        <Method as crate::Message>::default_instance()
     }
 }
 
@@ -598,7 +598,7 @@
     // repeated .google.protobuf.Option options = 6;
 
 
-    pub fn get_options(&self) -> &[::protobuf::well_known_types::Option] {
+    pub fn get_options(&self) -> &[crate::well_known_types::Option] {
         &self.options
     }
     pub fn clear_options(&mut self) {
@@ -606,37 +606,37 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_options(&mut self, v: ::protobuf::RepeatedField<::protobuf::well_known_types::Option>) {
+    pub fn set_options(&mut self, v: crate::RepeatedField<crate::well_known_types::Option>) {
         self.options = v;
     }
 
     // Mutable pointer to the field.
-    pub fn mut_options(&mut self) -> &mut ::protobuf::RepeatedField<::protobuf::well_known_types::Option> {
+    pub fn mut_options(&mut self) -> &mut crate::RepeatedField<crate::well_known_types::Option> {
         &mut self.options
     }
 
     // Take field
-    pub fn take_options(&mut self) -> ::protobuf::RepeatedField<::protobuf::well_known_types::Option> {
-        ::std::mem::replace(&mut self.options, ::protobuf::RepeatedField::new())
+    pub fn take_options(&mut self) -> crate::RepeatedField<crate::well_known_types::Option> {
+        ::std::mem::replace(&mut self.options, crate::RepeatedField::new())
     }
 
     // .google.protobuf.Syntax syntax = 7;
 
 
-    pub fn get_syntax(&self) -> ::protobuf::well_known_types::Syntax {
+    pub fn get_syntax(&self) -> crate::well_known_types::Syntax {
         self.syntax
     }
     pub fn clear_syntax(&mut self) {
-        self.syntax = ::protobuf::well_known_types::Syntax::SYNTAX_PROTO2;
+        self.syntax = crate::well_known_types::Syntax::SYNTAX_PROTO2;
     }
 
     // Param is passed by value, moved
-    pub fn set_syntax(&mut self, v: ::protobuf::well_known_types::Syntax) {
+    pub fn set_syntax(&mut self, v: crate::well_known_types::Syntax) {
         self.syntax = v;
     }
 }
 
-impl ::protobuf::Message for Method {
+impl crate::Message for Method {
     fn is_initialized(&self) -> bool {
         for v in &self.options {
             if !v.is_initialized() {
@@ -646,41 +646,41 @@
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::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.name)?;
+                    crate::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
                 },
                 2 => {
-                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.request_type_url)?;
+                    crate::rt::read_singular_proto3_string_into(wire_type, is, &mut self.request_type_url)?;
                 },
                 3 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_bool()?;
                     self.request_streaming = tmp;
                 },
                 4 => {
-                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.response_type_url)?;
+                    crate::rt::read_singular_proto3_string_into(wire_type, is, &mut self.response_type_url)?;
                 },
                 5 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_bool()?;
                     self.response_streaming = tmp;
                 },
                 6 => {
-                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.options)?;
+                    crate::rt::read_repeated_message_into(wire_type, is, &mut self.options)?;
                 },
                 7 => {
-                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.syntax, 7, &mut self.unknown_fields)?
+                    crate::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.syntax, 7, &mut self.unknown_fields)?
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -692,33 +692,33 @@
     fn compute_size(&self) -> u32 {
         let mut my_size = 0;
         if !self.name.is_empty() {
-            my_size += ::protobuf::rt::string_size(1, &self.name);
+            my_size += crate::rt::string_size(1, &self.name);
         }
         if !self.request_type_url.is_empty() {
-            my_size += ::protobuf::rt::string_size(2, &self.request_type_url);
+            my_size += crate::rt::string_size(2, &self.request_type_url);
         }
         if self.request_streaming != false {
             my_size += 2;
         }
         if !self.response_type_url.is_empty() {
-            my_size += ::protobuf::rt::string_size(4, &self.response_type_url);
+            my_size += crate::rt::string_size(4, &self.response_type_url);
         }
         if self.response_streaming != false {
             my_size += 2;
         }
         for value in &self.options {
             let len = value.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
         };
-        if self.syntax != ::protobuf::well_known_types::Syntax::SYNTAX_PROTO2 {
-            my_size += ::protobuf::rt::enum_size(7, self.syntax);
+        if self.syntax != crate::well_known_types::Syntax::SYNTAX_PROTO2 {
+            my_size += crate::rt::enum_size(7, self.syntax);
         }
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         if !self.name.is_empty() {
             os.write_string(1, &self.name)?;
         }
@@ -735,12 +735,12 @@
             os.write_bool(5, self.response_streaming)?;
         }
         for v in &self.options {
-            os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(6, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         };
-        if self.syntax != ::protobuf::well_known_types::Syntax::SYNTAX_PROTO2 {
-            os.write_enum(7, ::protobuf::ProtobufEnum::value(&self.syntax))?;
+        if self.syntax != crate::well_known_types::Syntax::SYNTAX_PROTO2 {
+            os.write_enum(7, crate::ProtobufEnum::value(&self.syntax))?;
         }
         os.write_unknown_fields(self.get_unknown_fields())?;
         ::std::result::Result::Ok(())
@@ -750,11 +750,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -768,7 +768,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -776,46 +776,46 @@
         Method::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "name",
                 |m: &Method| { &m.name },
                 |m: &mut Method| { &mut m.name },
             ));
-            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "request_type_url",
                 |m: &Method| { &m.request_type_url },
                 |m: &mut Method| { &mut m.request_type_url },
             ));
-            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
+            fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeBool>(
                 "request_streaming",
                 |m: &Method| { &m.request_streaming },
                 |m: &mut Method| { &mut m.request_streaming },
             ));
-            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "response_type_url",
                 |m: &Method| { &m.response_type_url },
                 |m: &mut Method| { &mut m.response_type_url },
             ));
-            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
+            fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeBool>(
                 "response_streaming",
                 |m: &Method| { &m.response_streaming },
                 |m: &mut Method| { &mut m.response_streaming },
             ));
-            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Option>>(
+            fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<crate::well_known_types::Option>>(
                 "options",
                 |m: &Method| { &m.options },
                 |m: &mut Method| { &mut m.options },
             ));
-            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<::protobuf::well_known_types::Syntax>>(
+            fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeEnum<crate::well_known_types::Syntax>>(
                 "syntax",
                 |m: &Method| { &m.syntax },
                 |m: &mut Method| { &mut m.syntax },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Method>(
+            crate::reflect::MessageDescriptor::new_pb_name::<Method>(
                 "Method",
                 fields,
                 file_descriptor_proto()
@@ -824,12 +824,12 @@
     }
 
     fn default_instance() -> &'static Method {
-        static instance: ::protobuf::rt::LazyV2<Method> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<Method> = crate::rt::LazyV2::INIT;
         instance.get(Method::new)
     }
 }
 
-impl ::protobuf::Clear for Method {
+impl crate::Clear for Method {
     fn clear(&mut self) {
         self.name.clear();
         self.request_type_url.clear();
@@ -837,20 +837,20 @@
         self.response_type_url.clear();
         self.response_streaming = false;
         self.options.clear();
-        self.syntax = ::protobuf::well_known_types::Syntax::SYNTAX_PROTO2;
+        self.syntax = crate::well_known_types::Syntax::SYNTAX_PROTO2;
         self.unknown_fields.clear();
     }
 }
 
 impl ::std::fmt::Debug for Method {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for Method {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for Method {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -862,14 +862,14 @@
     pub root: ::std::string::String,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a Mixin {
     fn default() -> &'a Mixin {
-        <Mixin as ::protobuf::Message>::default_instance()
+        <Mixin as crate::Message>::default_instance()
     }
 }
 
@@ -931,23 +931,23 @@
     }
 }
 
-impl ::protobuf::Message for Mixin {
+impl crate::Message for Mixin {
     fn is_initialized(&self) -> bool {
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::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.name)?;
+                    crate::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
                 },
                 2 => {
-                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.root)?;
+                    crate::rt::read_singular_proto3_string_into(wire_type, is, &mut self.root)?;
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -959,17 +959,17 @@
     fn compute_size(&self) -> u32 {
         let mut my_size = 0;
         if !self.name.is_empty() {
-            my_size += ::protobuf::rt::string_size(1, &self.name);
+            my_size += crate::rt::string_size(1, &self.name);
         }
         if !self.root.is_empty() {
-            my_size += ::protobuf::rt::string_size(2, &self.root);
+            my_size += crate::rt::string_size(2, &self.root);
         }
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         if !self.name.is_empty() {
             os.write_string(1, &self.name)?;
         }
@@ -984,11 +984,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -1002,7 +1002,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -1010,21 +1010,21 @@
         Mixin::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "name",
                 |m: &Mixin| { &m.name },
                 |m: &mut Mixin| { &mut m.name },
             ));
-            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "root",
                 |m: &Mixin| { &m.root },
                 |m: &mut Mixin| { &mut m.root },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Mixin>(
+            crate::reflect::MessageDescriptor::new_pb_name::<Mixin>(
                 "Mixin",
                 fields,
                 file_descriptor_proto()
@@ -1033,12 +1033,12 @@
     }
 
     fn default_instance() -> &'static Mixin {
-        static instance: ::protobuf::rt::LazyV2<Mixin> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<Mixin> = crate::rt::LazyV2::INIT;
         instance.get(Mixin::new)
     }
 }
 
-impl ::protobuf::Clear for Mixin {
+impl crate::Clear for Mixin {
     fn clear(&mut self) {
         self.name.clear();
         self.root.clear();
@@ -1048,13 +1048,13 @@
 
 impl ::std::fmt::Debug for Mixin {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for Mixin {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for Mixin {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -1266,13 +1266,13 @@
     \x03\x12\x04\xc7\x01\x10\x11b\x06proto3\
 ";
 
-static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;
+static file_descriptor_proto_lazy: crate::rt::LazyV2<crate::descriptor::FileDescriptorProto> = crate::rt::LazyV2::INIT;
 
-fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
-    ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap()
+fn parse_descriptor_proto() -> crate::descriptor::FileDescriptorProto {
+    crate::parse_from_bytes(file_descriptor_proto_data).unwrap()
 }
 
-pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
+pub fn file_descriptor_proto() -> &'static crate::descriptor::FileDescriptorProto {
     file_descriptor_proto_lazy.get(|| {
         parse_descriptor_proto()
     })
diff --git a/src/well_known_types/duration.rs b/src/well_known_types/duration.rs
index 7ca828f..623c19f 100644
--- a/src/well_known_types/duration.rs
+++ b/src/well_known_types/duration.rs
@@ -1,4 +1,4 @@
-// This file is generated by rust-protobuf 2.16.0-pre. Do not edit
+// This file is generated by rust-protobuf 2.17.0-pre. Do not edit
 // @generated
 
 // https://github.com/rust-lang/rust-clippy/issues/702
@@ -27,14 +27,14 @@
     pub nanos: i32,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a Duration {
     fn default() -> &'a Duration {
-        <Duration as ::protobuf::Message>::default_instance()
+        <Duration as crate::Message>::default_instance()
     }
 }
 
@@ -74,31 +74,31 @@
     }
 }
 
-impl ::protobuf::Message for Duration {
+impl crate::Message for Duration {
     fn is_initialized(&self) -> bool {
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::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));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_int64()?;
                     self.seconds = tmp;
                 },
                 2 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_int32()?;
                     self.nanos = tmp;
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -110,17 +110,17 @@
     fn compute_size(&self) -> u32 {
         let mut my_size = 0;
         if self.seconds != 0 {
-            my_size += ::protobuf::rt::value_size(1, self.seconds, ::protobuf::wire_format::WireTypeVarint);
+            my_size += crate::rt::value_size(1, self.seconds, crate::wire_format::WireTypeVarint);
         }
         if self.nanos != 0 {
-            my_size += ::protobuf::rt::value_size(2, self.nanos, ::protobuf::wire_format::WireTypeVarint);
+            my_size += crate::rt::value_size(2, self.nanos, crate::wire_format::WireTypeVarint);
         }
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         if self.seconds != 0 {
             os.write_int64(1, self.seconds)?;
         }
@@ -135,11 +135,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -153,7 +153,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -161,21 +161,21 @@
         Duration::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
+            fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeInt64>(
                 "seconds",
                 |m: &Duration| { &m.seconds },
                 |m: &mut Duration| { &mut m.seconds },
             ));
-            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
+            fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeInt32>(
                 "nanos",
                 |m: &Duration| { &m.nanos },
                 |m: &mut Duration| { &mut m.nanos },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Duration>(
+            crate::reflect::MessageDescriptor::new_pb_name::<Duration>(
                 "Duration",
                 fields,
                 file_descriptor_proto()
@@ -184,12 +184,12 @@
     }
 
     fn default_instance() -> &'static Duration {
-        static instance: ::protobuf::rt::LazyV2<Duration> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<Duration> = crate::rt::LazyV2::INIT;
         instance.get(Duration::new)
     }
 }
 
-impl ::protobuf::Clear for Duration {
+impl crate::Clear for Duration {
     fn clear(&mut self) {
         self.seconds = 0;
         self.nanos = 0;
@@ -199,13 +199,13 @@
 
 impl ::std::fmt::Debug for Duration {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for Duration {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for Duration {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -310,13 +310,13 @@
     \x03f\x08\r\n\x0c\n\x05\x04\0\x02\x01\x03\x12\x03f\x10\x11b\x06proto3\
 ";
 
-static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;
+static file_descriptor_proto_lazy: crate::rt::LazyV2<crate::descriptor::FileDescriptorProto> = crate::rt::LazyV2::INIT;
 
-fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
-    ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap()
+fn parse_descriptor_proto() -> crate::descriptor::FileDescriptorProto {
+    crate::parse_from_bytes(file_descriptor_proto_data).unwrap()
 }
 
-pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
+pub fn file_descriptor_proto() -> &'static crate::descriptor::FileDescriptorProto {
     file_descriptor_proto_lazy.get(|| {
         parse_descriptor_proto()
     })
diff --git a/src/well_known_types/empty.rs b/src/well_known_types/empty.rs
index 5e5b378..022f303 100644
--- a/src/well_known_types/empty.rs
+++ b/src/well_known_types/empty.rs
@@ -1,4 +1,4 @@
-// This file is generated by rust-protobuf 2.16.0-pre. Do not edit
+// This file is generated by rust-protobuf 2.17.0-pre. Do not edit
 // @generated
 
 // https://github.com/rust-lang/rust-clippy/issues/702
@@ -24,14 +24,14 @@
 pub struct Empty {
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a Empty {
     fn default() -> &'a Empty {
-        <Empty as ::protobuf::Message>::default_instance()
+        <Empty as crate::Message>::default_instance()
     }
 }
 
@@ -41,17 +41,17 @@
     }
 }
 
-impl ::protobuf::Message for Empty {
+impl crate::Message for Empty {
     fn is_initialized(&self) -> bool {
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::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())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -62,12 +62,12 @@
     #[allow(unused_variables)]
     fn compute_size(&self) -> u32 {
         let mut my_size = 0;
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         os.write_unknown_fields(self.get_unknown_fields())?;
         ::std::result::Result::Ok(())
     }
@@ -76,11 +76,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -94,7 +94,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -102,11 +102,11 @@
         Empty::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let fields = ::std::vec::Vec::new();
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Empty>(
+            crate::reflect::MessageDescriptor::new_pb_name::<Empty>(
                 "Empty",
                 fields,
                 file_descriptor_proto()
@@ -115,12 +115,12 @@
     }
 
     fn default_instance() -> &'static Empty {
-        static instance: ::protobuf::rt::LazyV2<Empty> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<Empty> = crate::rt::LazyV2::INIT;
         instance.get(Empty::new)
     }
 }
 
-impl ::protobuf::Clear for Empty {
+impl crate::Clear for Empty {
     fn clear(&mut self) {
         self.unknown_fields.clear();
     }
@@ -128,13 +128,13 @@
 
 impl ::std::fmt::Debug for Empty {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for Empty {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for Empty {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -195,13 +195,13 @@
     \x12\x033\x08\rb\x06proto3\
 ";
 
-static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;
+static file_descriptor_proto_lazy: crate::rt::LazyV2<crate::descriptor::FileDescriptorProto> = crate::rt::LazyV2::INIT;
 
-fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
-    ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap()
+fn parse_descriptor_proto() -> crate::descriptor::FileDescriptorProto {
+    crate::parse_from_bytes(file_descriptor_proto_data).unwrap()
 }
 
-pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
+pub fn file_descriptor_proto() -> &'static crate::descriptor::FileDescriptorProto {
     file_descriptor_proto_lazy.get(|| {
         parse_descriptor_proto()
     })
diff --git a/src/well_known_types/field_mask.rs b/src/well_known_types/field_mask.rs
index 62186f9..37c03f4 100644
--- a/src/well_known_types/field_mask.rs
+++ b/src/well_known_types/field_mask.rs
@@ -1,4 +1,4 @@
-// This file is generated by rust-protobuf 2.16.0-pre. Do not edit
+// This file is generated by rust-protobuf 2.17.0-pre. Do not edit
 // @generated
 
 // https://github.com/rust-lang/rust-clippy/issues/702
@@ -23,17 +23,17 @@
 #[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
 pub struct FieldMask {
     // message fields
-    pub paths: ::protobuf::RepeatedField<::std::string::String>,
+    pub paths: crate::RepeatedField<::std::string::String>,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a FieldMask {
     fn default() -> &'a FieldMask {
-        <FieldMask as ::protobuf::Message>::default_instance()
+        <FieldMask as crate::Message>::default_instance()
     }
 }
 
@@ -53,35 +53,35 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_paths(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
+    pub fn set_paths(&mut self, v: crate::RepeatedField<::std::string::String>) {
         self.paths = v;
     }
 
     // Mutable pointer to the field.
-    pub fn mut_paths(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
+    pub fn mut_paths(&mut self) -> &mut crate::RepeatedField<::std::string::String> {
         &mut self.paths
     }
 
     // Take field
-    pub fn take_paths(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
-        ::std::mem::replace(&mut self.paths, ::protobuf::RepeatedField::new())
+    pub fn take_paths(&mut self) -> crate::RepeatedField<::std::string::String> {
+        ::std::mem::replace(&mut self.paths, crate::RepeatedField::new())
     }
 }
 
-impl ::protobuf::Message for FieldMask {
+impl crate::Message for FieldMask {
     fn is_initialized(&self) -> bool {
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::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.paths)?;
+                    crate::rt::read_repeated_string_into(wire_type, is, &mut self.paths)?;
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -93,14 +93,14 @@
     fn compute_size(&self) -> u32 {
         let mut my_size = 0;
         for value in &self.paths {
-            my_size += ::protobuf::rt::string_size(1, &value);
+            my_size += crate::rt::string_size(1, &value);
         };
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         for v in &self.paths {
             os.write_string(1, &v)?;
         };
@@ -112,11 +112,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -130,7 +130,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -138,16 +138,16 @@
         FieldMask::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "paths",
                 |m: &FieldMask| { &m.paths },
                 |m: &mut FieldMask| { &mut m.paths },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<FieldMask>(
+            crate::reflect::MessageDescriptor::new_pb_name::<FieldMask>(
                 "FieldMask",
                 fields,
                 file_descriptor_proto()
@@ -156,12 +156,12 @@
     }
 
     fn default_instance() -> &'static FieldMask {
-        static instance: ::protobuf::rt::LazyV2<FieldMask> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<FieldMask> = crate::rt::LazyV2::INIT;
         instance.get(FieldMask::new)
     }
 }
 
-impl ::protobuf::Clear for FieldMask {
+impl crate::Clear for FieldMask {
     fn clear(&mut self) {
         self.paths.clear();
         self.unknown_fields.clear();
@@ -170,13 +170,13 @@
 
 impl ::std::fmt::Debug for FieldMask {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for FieldMask {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for FieldMask {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -366,13 +366,13 @@
     \x01\x1a\x1bb\x06proto3\
 ";
 
-static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;
+static file_descriptor_proto_lazy: crate::rt::LazyV2<crate::descriptor::FileDescriptorProto> = crate::rt::LazyV2::INIT;
 
-fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
-    ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap()
+fn parse_descriptor_proto() -> crate::descriptor::FileDescriptorProto {
+    crate::parse_from_bytes(file_descriptor_proto_data).unwrap()
 }
 
-pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
+pub fn file_descriptor_proto() -> &'static crate::descriptor::FileDescriptorProto {
     file_descriptor_proto_lazy.get(|| {
         parse_descriptor_proto()
     })
diff --git a/src/well_known_types/source_context.rs b/src/well_known_types/source_context.rs
index 8145ba6..9583d89 100644
--- a/src/well_known_types/source_context.rs
+++ b/src/well_known_types/source_context.rs
@@ -1,4 +1,4 @@
-// This file is generated by rust-protobuf 2.16.0-pre. Do not edit
+// This file is generated by rust-protobuf 2.17.0-pre. Do not edit
 // @generated
 
 // https://github.com/rust-lang/rust-clippy/issues/702
@@ -26,14 +26,14 @@
     pub file_name: ::std::string::String,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a SourceContext {
     fn default() -> &'a SourceContext {
-        <SourceContext as ::protobuf::Message>::default_instance()
+        <SourceContext as crate::Message>::default_instance()
     }
 }
 
@@ -69,20 +69,20 @@
     }
 }
 
-impl ::protobuf::Message for SourceContext {
+impl crate::Message for SourceContext {
     fn is_initialized(&self) -> bool {
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::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.file_name)?;
+                    crate::rt::read_singular_proto3_string_into(wire_type, is, &mut self.file_name)?;
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -94,14 +94,14 @@
     fn compute_size(&self) -> u32 {
         let mut my_size = 0;
         if !self.file_name.is_empty() {
-            my_size += ::protobuf::rt::string_size(1, &self.file_name);
+            my_size += crate::rt::string_size(1, &self.file_name);
         }
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         if !self.file_name.is_empty() {
             os.write_string(1, &self.file_name)?;
         }
@@ -113,11 +113,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -131,7 +131,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -139,16 +139,16 @@
         SourceContext::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "file_name",
                 |m: &SourceContext| { &m.file_name },
                 |m: &mut SourceContext| { &mut m.file_name },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<SourceContext>(
+            crate::reflect::MessageDescriptor::new_pb_name::<SourceContext>(
                 "SourceContext",
                 fields,
                 file_descriptor_proto()
@@ -157,12 +157,12 @@
     }
 
     fn default_instance() -> &'static SourceContext {
-        static instance: ::protobuf::rt::LazyV2<SourceContext> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<SourceContext> = crate::rt::LazyV2::INIT;
         instance.get(SourceContext::new)
     }
 }
 
-impl ::protobuf::Clear for SourceContext {
+impl crate::Clear for SourceContext {
     fn clear(&mut self) {
         self.file_name.clear();
         self.unknown_fields.clear();
@@ -171,13 +171,13 @@
 
 impl ::std::fmt::Debug for SourceContext {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for SourceContext {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for SourceContext {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -236,13 +236,13 @@
     \0\x02\0\x03\x12\x03-\x15\x16b\x06proto3\
 ";
 
-static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;
+static file_descriptor_proto_lazy: crate::rt::LazyV2<crate::descriptor::FileDescriptorProto> = crate::rt::LazyV2::INIT;
 
-fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
-    ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap()
+fn parse_descriptor_proto() -> crate::descriptor::FileDescriptorProto {
+    crate::parse_from_bytes(file_descriptor_proto_data).unwrap()
 }
 
-pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
+pub fn file_descriptor_proto() -> &'static crate::descriptor::FileDescriptorProto {
     file_descriptor_proto_lazy.get(|| {
         parse_descriptor_proto()
     })
diff --git a/src/well_known_types/struct_pb.rs b/src/well_known_types/struct_pb.rs
index 973aba8..0045a09 100644
--- a/src/well_known_types/struct_pb.rs
+++ b/src/well_known_types/struct_pb.rs
@@ -1,4 +1,4 @@
-// This file is generated by rust-protobuf 2.16.0-pre. Do not edit
+// This file is generated by rust-protobuf 2.17.0-pre. Do not edit
 // @generated
 
 // https://github.com/rust-lang/rust-clippy/issues/702
@@ -26,14 +26,14 @@
     pub fields: ::std::collections::HashMap<::std::string::String, Value>,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a Struct {
     fn default() -> &'a Struct {
-        <Struct as ::protobuf::Message>::default_instance()
+        <Struct as crate::Message>::default_instance()
     }
 }
 
@@ -68,20 +68,20 @@
     }
 }
 
-impl ::protobuf::Message for Struct {
+impl crate::Message for Struct {
     fn is_initialized(&self) -> bool {
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::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::ProtobufTypeMessage<Value>>(wire_type, is, &mut self.fields)?;
+                    crate::rt::read_map_into::<crate::types::ProtobufTypeString, crate::types::ProtobufTypeMessage<Value>>(wire_type, is, &mut self.fields)?;
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -92,14 +92,14 @@
     #[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::ProtobufTypeMessage<Value>>(1, &self.fields);
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::rt::compute_map_size::<crate::types::ProtobufTypeString, crate::types::ProtobufTypeMessage<Value>>(1, &self.fields);
+        my_size += crate::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::ProtobufTypeMessage<Value>>(1, &self.fields, os)?;
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
+        crate::rt::write_map_with_cached_sizes::<crate::types::ProtobufTypeString, crate::types::ProtobufTypeMessage<Value>>(1, &self.fields, os)?;
         os.write_unknown_fields(self.get_unknown_fields())?;
         ::std::result::Result::Ok(())
     }
@@ -108,11 +108,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -126,7 +126,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -134,16 +134,16 @@
         Struct::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<Value>>(
+            fields.push(crate::reflect::accessor::make_map_accessor::<_, crate::types::ProtobufTypeString, crate::types::ProtobufTypeMessage<Value>>(
                 "fields",
                 |m: &Struct| { &m.fields },
                 |m: &mut Struct| { &mut m.fields },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Struct>(
+            crate::reflect::MessageDescriptor::new_pb_name::<Struct>(
                 "Struct",
                 fields,
                 file_descriptor_proto()
@@ -152,12 +152,12 @@
     }
 
     fn default_instance() -> &'static Struct {
-        static instance: ::protobuf::rt::LazyV2<Struct> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<Struct> = crate::rt::LazyV2::INIT;
         instance.get(Struct::new)
     }
 }
 
-impl ::protobuf::Clear for Struct {
+impl crate::Clear for Struct {
     fn clear(&mut self) {
         self.fields.clear();
         self.unknown_fields.clear();
@@ -166,13 +166,13 @@
 
 impl ::std::fmt::Debug for Struct {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for Struct {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for Struct {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -183,14 +183,14 @@
     pub kind: ::std::option::Option<Value_oneof_kind>,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a Value {
     fn default() -> &'a Value {
-        <Value as ::protobuf::Message>::default_instance()
+        <Value as crate::Message>::default_instance()
     }
 }
 
@@ -340,7 +340,7 @@
     pub fn get_struct_value(&self) -> &Struct {
         match self.kind {
             ::std::option::Option::Some(Value_oneof_kind::struct_value(ref v)) => v,
-            _ => <Struct as ::protobuf::Message>::default_instance(),
+            _ => <Struct as crate::Message>::default_instance(),
         }
     }
     pub fn clear_struct_value(&mut self) {
@@ -389,7 +389,7 @@
     pub fn get_list_value(&self) -> &ListValue {
         match self.kind {
             ::std::option::Option::Some(Value_oneof_kind::list_value(ref v)) => v,
-            _ => <ListValue as ::protobuf::Message>::default_instance(),
+            _ => <ListValue as crate::Message>::default_instance(),
         }
     }
     pub fn clear_list_value(&mut self) {
@@ -433,7 +433,7 @@
     }
 }
 
-impl ::protobuf::Message for Value {
+impl crate::Message for Value {
     fn is_initialized(&self) -> bool {
         if let Some(Value_oneof_kind::struct_value(ref v)) = self.kind {
             if !v.is_initialized() {
@@ -448,48 +448,48 @@
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::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));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     self.kind = ::std::option::Option::Some(Value_oneof_kind::null_value(is.read_enum()?));
                 },
                 2 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeFixed64 {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     self.kind = ::std::option::Option::Some(Value_oneof_kind::number_value(is.read_double()?));
                 },
                 3 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeLengthDelimited {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     self.kind = ::std::option::Option::Some(Value_oneof_kind::string_value(is.read_string()?));
                 },
                 4 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     self.kind = ::std::option::Option::Some(Value_oneof_kind::bool_value(is.read_bool()?));
                 },
                 5 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeLengthDelimited {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     self.kind = ::std::option::Option::Some(Value_oneof_kind::struct_value(is.read_message()?));
                 },
                 6 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeLengthDelimited {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     self.kind = ::std::option::Option::Some(Value_oneof_kind::list_value(is.read_message()?));
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -503,37 +503,37 @@
         if let ::std::option::Option::Some(ref v) = self.kind {
             match v {
                 &Value_oneof_kind::null_value(v) => {
-                    my_size += ::protobuf::rt::enum_size(1, v);
+                    my_size += crate::rt::enum_size(1, v);
                 },
                 &Value_oneof_kind::number_value(v) => {
                     my_size += 9;
                 },
                 &Value_oneof_kind::string_value(ref v) => {
-                    my_size += ::protobuf::rt::string_size(3, &v);
+                    my_size += crate::rt::string_size(3, &v);
                 },
                 &Value_oneof_kind::bool_value(v) => {
                     my_size += 2;
                 },
                 &Value_oneof_kind::struct_value(ref v) => {
                     let len = v.compute_size();
-                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+                    my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
                 },
                 &Value_oneof_kind::list_value(ref v) => {
                     let len = v.compute_size();
-                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+                    my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
                 },
             };
         }
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         if let ::std::option::Option::Some(ref v) = self.kind {
             match v {
                 &Value_oneof_kind::null_value(v) => {
-                    os.write_enum(1, ::protobuf::ProtobufEnum::value(&v))?;
+                    os.write_enum(1, crate::ProtobufEnum::value(&v))?;
                 },
                 &Value_oneof_kind::number_value(v) => {
                     os.write_double(2, v)?;
@@ -545,12 +545,12 @@
                     os.write_bool(4, v)?;
                 },
                 &Value_oneof_kind::struct_value(ref v) => {
-                    os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+                    os.write_tag(5, crate::wire_format::WireTypeLengthDelimited)?;
                     os.write_raw_varint32(v.get_cached_size())?;
                     v.write_to_with_cached_sizes(os)?;
                 },
                 &Value_oneof_kind::list_value(ref v) => {
-                    os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+                    os.write_tag(6, crate::wire_format::WireTypeLengthDelimited)?;
                     os.write_raw_varint32(v.get_cached_size())?;
                     v.write_to_with_cached_sizes(os)?;
                 },
@@ -564,11 +564,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -582,7 +582,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -590,41 +590,41 @@
         Value::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_singular_enum_accessor::<_, NullValue>(
+            fields.push(crate::reflect::accessor::make_singular_enum_accessor::<_, NullValue>(
                 "null_value",
                 Value::has_null_value,
                 Value::get_null_value,
             ));
-            fields.push(::protobuf::reflect::accessor::make_singular_f64_accessor::<_>(
+            fields.push(crate::reflect::accessor::make_singular_f64_accessor::<_>(
                 "number_value",
                 Value::has_number_value,
                 Value::get_number_value,
             ));
-            fields.push(::protobuf::reflect::accessor::make_singular_string_accessor::<_>(
+            fields.push(crate::reflect::accessor::make_singular_string_accessor::<_>(
                 "string_value",
                 Value::has_string_value,
                 Value::get_string_value,
             ));
-            fields.push(::protobuf::reflect::accessor::make_singular_bool_accessor::<_>(
+            fields.push(crate::reflect::accessor::make_singular_bool_accessor::<_>(
                 "bool_value",
                 Value::has_bool_value,
                 Value::get_bool_value,
             ));
-            fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, Struct>(
+            fields.push(crate::reflect::accessor::make_singular_message_accessor::<_, Struct>(
                 "struct_value",
                 Value::has_struct_value,
                 Value::get_struct_value,
             ));
-            fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, ListValue>(
+            fields.push(crate::reflect::accessor::make_singular_message_accessor::<_, ListValue>(
                 "list_value",
                 Value::has_list_value,
                 Value::get_list_value,
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Value>(
+            crate::reflect::MessageDescriptor::new_pb_name::<Value>(
                 "Value",
                 fields,
                 file_descriptor_proto()
@@ -633,12 +633,12 @@
     }
 
     fn default_instance() -> &'static Value {
-        static instance: ::protobuf::rt::LazyV2<Value> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<Value> = crate::rt::LazyV2::INIT;
         instance.get(Value::new)
     }
 }
 
-impl ::protobuf::Clear for Value {
+impl crate::Clear for Value {
     fn clear(&mut self) {
         self.kind = ::std::option::Option::None;
         self.kind = ::std::option::Option::None;
@@ -652,13 +652,13 @@
 
 impl ::std::fmt::Debug for Value {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for Value {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for Value {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -666,17 +666,17 @@
 #[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
 pub struct ListValue {
     // message fields
-    pub values: ::protobuf::RepeatedField<Value>,
+    pub values: crate::RepeatedField<Value>,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a ListValue {
     fn default() -> &'a ListValue {
-        <ListValue as ::protobuf::Message>::default_instance()
+        <ListValue as crate::Message>::default_instance()
     }
 }
 
@@ -696,22 +696,22 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_values(&mut self, v: ::protobuf::RepeatedField<Value>) {
+    pub fn set_values(&mut self, v: crate::RepeatedField<Value>) {
         self.values = v;
     }
 
     // Mutable pointer to the field.
-    pub fn mut_values(&mut self) -> &mut ::protobuf::RepeatedField<Value> {
+    pub fn mut_values(&mut self) -> &mut crate::RepeatedField<Value> {
         &mut self.values
     }
 
     // Take field
-    pub fn take_values(&mut self) -> ::protobuf::RepeatedField<Value> {
-        ::std::mem::replace(&mut self.values, ::protobuf::RepeatedField::new())
+    pub fn take_values(&mut self) -> crate::RepeatedField<Value> {
+        ::std::mem::replace(&mut self.values, crate::RepeatedField::new())
     }
 }
 
-impl ::protobuf::Message for ListValue {
+impl crate::Message for ListValue {
     fn is_initialized(&self) -> bool {
         for v in &self.values {
             if !v.is_initialized() {
@@ -721,15 +721,15 @@
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
         while !is.eof()? {
             let (field_number, wire_type) = is.read_tag_unpack()?;
             match field_number {
                 1 => {
-                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.values)?;
+                    crate::rt::read_repeated_message_into(wire_type, is, &mut self.values)?;
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -742,16 +742,16 @@
         let mut my_size = 0;
         for value in &self.values {
             let len = value.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
         };
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         for v in &self.values {
-            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(1, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         };
@@ -763,11 +763,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -781,7 +781,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -789,16 +789,16 @@
         ListValue::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Value>>(
+            fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<Value>>(
                 "values",
                 |m: &ListValue| { &m.values },
                 |m: &mut ListValue| { &mut m.values },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ListValue>(
+            crate::reflect::MessageDescriptor::new_pb_name::<ListValue>(
                 "ListValue",
                 fields,
                 file_descriptor_proto()
@@ -807,12 +807,12 @@
     }
 
     fn default_instance() -> &'static ListValue {
-        static instance: ::protobuf::rt::LazyV2<ListValue> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<ListValue> = crate::rt::LazyV2::INIT;
         instance.get(ListValue::new)
     }
 }
 
-impl ::protobuf::Clear for ListValue {
+impl crate::Clear for ListValue {
     fn clear(&mut self) {
         self.values.clear();
         self.unknown_fields.clear();
@@ -821,13 +821,13 @@
 
 impl ::std::fmt::Debug for ListValue {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for ListValue {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for ListValue {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -837,7 +837,7 @@
     NULL_VALUE = 0,
 }
 
-impl ::protobuf::ProtobufEnum for NullValue {
+impl crate::ProtobufEnum for NullValue {
     fn value(&self) -> i32 {
         *self as i32
     }
@@ -856,10 +856,10 @@
         values
     }
 
-    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn enum_descriptor_static() -> &'static crate::reflect::EnumDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::EnumDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
-            ::protobuf::reflect::EnumDescriptor::new_pb_name::<NullValue>("NullValue", file_descriptor_proto())
+            crate::reflect::EnumDescriptor::new_pb_name::<NullValue>("NullValue", file_descriptor_proto())
         })
     }
 }
@@ -873,9 +873,9 @@
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for NullValue {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
+impl crate::reflect::ProtobufValue for NullValue {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Enum(crate::ProtobufEnum::descriptor(self))
     }
 }
 
@@ -996,13 +996,13 @@
     \x03^\x11\x17\n\x0c\n\x05\x04\x02\x02\0\x03\x12\x03^\x1a\x1bb\x06proto3\
 ";
 
-static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;
+static file_descriptor_proto_lazy: crate::rt::LazyV2<crate::descriptor::FileDescriptorProto> = crate::rt::LazyV2::INIT;
 
-fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
-    ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap()
+fn parse_descriptor_proto() -> crate::descriptor::FileDescriptorProto {
+    crate::parse_from_bytes(file_descriptor_proto_data).unwrap()
 }
 
-pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
+pub fn file_descriptor_proto() -> &'static crate::descriptor::FileDescriptorProto {
     file_descriptor_proto_lazy.get(|| {
         parse_descriptor_proto()
     })
diff --git a/src/well_known_types/timestamp.rs b/src/well_known_types/timestamp.rs
index 3ba6090..ef76de4 100644
--- a/src/well_known_types/timestamp.rs
+++ b/src/well_known_types/timestamp.rs
@@ -1,4 +1,4 @@
-// This file is generated by rust-protobuf 2.16.0-pre. Do not edit
+// This file is generated by rust-protobuf 2.17.0-pre. Do not edit
 // @generated
 
 // https://github.com/rust-lang/rust-clippy/issues/702
@@ -27,14 +27,14 @@
     pub nanos: i32,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a Timestamp {
     fn default() -> &'a Timestamp {
-        <Timestamp as ::protobuf::Message>::default_instance()
+        <Timestamp as crate::Message>::default_instance()
     }
 }
 
@@ -74,31 +74,31 @@
     }
 }
 
-impl ::protobuf::Message for Timestamp {
+impl crate::Message for Timestamp {
     fn is_initialized(&self) -> bool {
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::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));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_int64()?;
                     self.seconds = tmp;
                 },
                 2 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_int32()?;
                     self.nanos = tmp;
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -110,17 +110,17 @@
     fn compute_size(&self) -> u32 {
         let mut my_size = 0;
         if self.seconds != 0 {
-            my_size += ::protobuf::rt::value_size(1, self.seconds, ::protobuf::wire_format::WireTypeVarint);
+            my_size += crate::rt::value_size(1, self.seconds, crate::wire_format::WireTypeVarint);
         }
         if self.nanos != 0 {
-            my_size += ::protobuf::rt::value_size(2, self.nanos, ::protobuf::wire_format::WireTypeVarint);
+            my_size += crate::rt::value_size(2, self.nanos, crate::wire_format::WireTypeVarint);
         }
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         if self.seconds != 0 {
             os.write_int64(1, self.seconds)?;
         }
@@ -135,11 +135,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -153,7 +153,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -161,21 +161,21 @@
         Timestamp::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
+            fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeInt64>(
                 "seconds",
                 |m: &Timestamp| { &m.seconds },
                 |m: &mut Timestamp| { &mut m.seconds },
             ));
-            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
+            fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeInt32>(
                 "nanos",
                 |m: &Timestamp| { &m.nanos },
                 |m: &mut Timestamp| { &mut m.nanos },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Timestamp>(
+            crate::reflect::MessageDescriptor::new_pb_name::<Timestamp>(
                 "Timestamp",
                 fields,
                 file_descriptor_proto()
@@ -184,12 +184,12 @@
     }
 
     fn default_instance() -> &'static Timestamp {
-        static instance: ::protobuf::rt::LazyV2<Timestamp> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<Timestamp> = crate::rt::LazyV2::INIT;
         instance.get(Timestamp::new)
     }
 }
 
-impl ::protobuf::Clear for Timestamp {
+impl crate::Clear for Timestamp {
     fn clear(&mut self) {
         self.seconds = 0;
         self.nanos = 0;
@@ -199,13 +199,13 @@
 
 impl ::std::fmt::Debug for Timestamp {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for Timestamp {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for Timestamp {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -313,13 +313,13 @@
     roto3\
 ";
 
-static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;
+static file_descriptor_proto_lazy: crate::rt::LazyV2<crate::descriptor::FileDescriptorProto> = crate::rt::LazyV2::INIT;
 
-fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
-    ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap()
+fn parse_descriptor_proto() -> crate::descriptor::FileDescriptorProto {
+    crate::parse_from_bytes(file_descriptor_proto_data).unwrap()
 }
 
-pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
+pub fn file_descriptor_proto() -> &'static crate::descriptor::FileDescriptorProto {
     file_descriptor_proto_lazy.get(|| {
         parse_descriptor_proto()
     })
diff --git a/src/well_known_types/type_pb.rs b/src/well_known_types/type_pb.rs
index 021300f..3150134 100644
--- a/src/well_known_types/type_pb.rs
+++ b/src/well_known_types/type_pb.rs
@@ -1,4 +1,4 @@
-// This file is generated by rust-protobuf 2.16.0-pre. Do not edit
+// This file is generated by rust-protobuf 2.17.0-pre. Do not edit
 // @generated
 
 // https://github.com/rust-lang/rust-clippy/issues/702
@@ -24,21 +24,21 @@
 pub struct Type {
     // message fields
     pub name: ::std::string::String,
-    pub fields: ::protobuf::RepeatedField<Field>,
-    pub oneofs: ::protobuf::RepeatedField<::std::string::String>,
-    pub options: ::protobuf::RepeatedField<Option>,
-    pub source_context: ::protobuf::SingularPtrField<::protobuf::well_known_types::SourceContext>,
+    pub fields: crate::RepeatedField<Field>,
+    pub oneofs: crate::RepeatedField<::std::string::String>,
+    pub options: crate::RepeatedField<Option>,
+    pub source_context: crate::SingularPtrField<crate::well_known_types::SourceContext>,
     pub syntax: Syntax,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a Type {
     fn default() -> &'a Type {
-        <Type as ::protobuf::Message>::default_instance()
+        <Type as crate::Message>::default_instance()
     }
 }
 
@@ -84,18 +84,18 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_fields(&mut self, v: ::protobuf::RepeatedField<Field>) {
+    pub fn set_fields(&mut self, v: crate::RepeatedField<Field>) {
         self.fields = v;
     }
 
     // Mutable pointer to the field.
-    pub fn mut_fields(&mut self) -> &mut ::protobuf::RepeatedField<Field> {
+    pub fn mut_fields(&mut self) -> &mut crate::RepeatedField<Field> {
         &mut self.fields
     }
 
     // Take field
-    pub fn take_fields(&mut self) -> ::protobuf::RepeatedField<Field> {
-        ::std::mem::replace(&mut self.fields, ::protobuf::RepeatedField::new())
+    pub fn take_fields(&mut self) -> crate::RepeatedField<Field> {
+        ::std::mem::replace(&mut self.fields, crate::RepeatedField::new())
     }
 
     // repeated string oneofs = 3;
@@ -109,18 +109,18 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_oneofs(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
+    pub fn set_oneofs(&mut self, v: crate::RepeatedField<::std::string::String>) {
         self.oneofs = v;
     }
 
     // Mutable pointer to the field.
-    pub fn mut_oneofs(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
+    pub fn mut_oneofs(&mut self) -> &mut crate::RepeatedField<::std::string::String> {
         &mut self.oneofs
     }
 
     // Take field
-    pub fn take_oneofs(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
-        ::std::mem::replace(&mut self.oneofs, ::protobuf::RepeatedField::new())
+    pub fn take_oneofs(&mut self) -> crate::RepeatedField<::std::string::String> {
+        ::std::mem::replace(&mut self.oneofs, crate::RepeatedField::new())
     }
 
     // repeated .google.protobuf.Option options = 4;
@@ -134,25 +134,25 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_options(&mut self, v: ::protobuf::RepeatedField<Option>) {
+    pub fn set_options(&mut self, v: crate::RepeatedField<Option>) {
         self.options = v;
     }
 
     // Mutable pointer to the field.
-    pub fn mut_options(&mut self) -> &mut ::protobuf::RepeatedField<Option> {
+    pub fn mut_options(&mut self) -> &mut crate::RepeatedField<Option> {
         &mut self.options
     }
 
     // Take field
-    pub fn take_options(&mut self) -> ::protobuf::RepeatedField<Option> {
-        ::std::mem::replace(&mut self.options, ::protobuf::RepeatedField::new())
+    pub fn take_options(&mut self) -> crate::RepeatedField<Option> {
+        ::std::mem::replace(&mut self.options, crate::RepeatedField::new())
     }
 
     // .google.protobuf.SourceContext source_context = 5;
 
 
-    pub fn get_source_context(&self) -> &::protobuf::well_known_types::SourceContext {
-        self.source_context.as_ref().unwrap_or_else(|| <::protobuf::well_known_types::SourceContext as ::protobuf::Message>::default_instance())
+    pub fn get_source_context(&self) -> &crate::well_known_types::SourceContext {
+        self.source_context.as_ref().unwrap_or_else(|| <crate::well_known_types::SourceContext as crate::Message>::default_instance())
     }
     pub fn clear_source_context(&mut self) {
         self.source_context.clear();
@@ -163,13 +163,13 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_source_context(&mut self, v: ::protobuf::well_known_types::SourceContext) {
-        self.source_context = ::protobuf::SingularPtrField::some(v);
+    pub fn set_source_context(&mut self, v: crate::well_known_types::SourceContext) {
+        self.source_context = crate::SingularPtrField::some(v);
     }
 
     // Mutable pointer to the field.
     // If field is not initialized, it is initialized with default value first.
-    pub fn mut_source_context(&mut self) -> &mut ::protobuf::well_known_types::SourceContext {
+    pub fn mut_source_context(&mut self) -> &mut crate::well_known_types::SourceContext {
         if self.source_context.is_none() {
             self.source_context.set_default();
         }
@@ -177,8 +177,8 @@
     }
 
     // Take field
-    pub fn take_source_context(&mut self) -> ::protobuf::well_known_types::SourceContext {
-        self.source_context.take().unwrap_or_else(|| ::protobuf::well_known_types::SourceContext::new())
+    pub fn take_source_context(&mut self) -> crate::well_known_types::SourceContext {
+        self.source_context.take().unwrap_or_else(|| crate::well_known_types::SourceContext::new())
     }
 
     // .google.protobuf.Syntax syntax = 6;
@@ -197,7 +197,7 @@
     }
 }
 
-impl ::protobuf::Message for Type {
+impl crate::Message for Type {
     fn is_initialized(&self) -> bool {
         for v in &self.fields {
             if !v.is_initialized() {
@@ -217,30 +217,30 @@
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::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.name)?;
+                    crate::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
                 },
                 2 => {
-                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.fields)?;
+                    crate::rt::read_repeated_message_into(wire_type, is, &mut self.fields)?;
                 },
                 3 => {
-                    ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.oneofs)?;
+                    crate::rt::read_repeated_string_into(wire_type, is, &mut self.oneofs)?;
                 },
                 4 => {
-                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.options)?;
+                    crate::rt::read_repeated_message_into(wire_type, is, &mut self.options)?;
                 },
                 5 => {
-                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.source_context)?;
+                    crate::rt::read_singular_message_into(wire_type, is, &mut self.source_context)?;
                 },
                 6 => {
-                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.syntax, 6, &mut self.unknown_fields)?
+                    crate::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.syntax, 6, &mut self.unknown_fields)?
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -252,37 +252,37 @@
     fn compute_size(&self) -> u32 {
         let mut my_size = 0;
         if !self.name.is_empty() {
-            my_size += ::protobuf::rt::string_size(1, &self.name);
+            my_size += crate::rt::string_size(1, &self.name);
         }
         for value in &self.fields {
             let len = value.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
         };
         for value in &self.oneofs {
-            my_size += ::protobuf::rt::string_size(3, &value);
+            my_size += crate::rt::string_size(3, &value);
         };
         for value in &self.options {
             let len = value.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
         };
         if let Some(ref v) = self.source_context.as_ref() {
             let len = v.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
         }
         if self.syntax != Syntax::SYNTAX_PROTO2 {
-            my_size += ::protobuf::rt::enum_size(6, self.syntax);
+            my_size += crate::rt::enum_size(6, self.syntax);
         }
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         if !self.name.is_empty() {
             os.write_string(1, &self.name)?;
         }
         for v in &self.fields {
-            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(2, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         };
@@ -290,17 +290,17 @@
             os.write_string(3, &v)?;
         };
         for v in &self.options {
-            os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(4, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         };
         if let Some(ref v) = self.source_context.as_ref() {
-            os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(5, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         }
         if self.syntax != Syntax::SYNTAX_PROTO2 {
-            os.write_enum(6, ::protobuf::ProtobufEnum::value(&self.syntax))?;
+            os.write_enum(6, crate::ProtobufEnum::value(&self.syntax))?;
         }
         os.write_unknown_fields(self.get_unknown_fields())?;
         ::std::result::Result::Ok(())
@@ -310,11 +310,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -328,7 +328,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -336,41 +336,41 @@
         Type::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "name",
                 |m: &Type| { &m.name },
                 |m: &mut Type| { &mut m.name },
             ));
-            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Field>>(
+            fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<Field>>(
                 "fields",
                 |m: &Type| { &m.fields },
                 |m: &mut Type| { &mut m.fields },
             ));
-            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "oneofs",
                 |m: &Type| { &m.oneofs },
                 |m: &mut Type| { &mut m.oneofs },
             ));
-            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Option>>(
+            fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<Option>>(
                 "options",
                 |m: &Type| { &m.options },
                 |m: &mut Type| { &mut m.options },
             ));
-            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::SourceContext>>(
+            fields.push(crate::reflect::accessor::make_singular_ptr_field_accessor::<_, crate::types::ProtobufTypeMessage<crate::well_known_types::SourceContext>>(
                 "source_context",
                 |m: &Type| { &m.source_context },
                 |m: &mut Type| { &mut m.source_context },
             ));
-            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<Syntax>>(
+            fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeEnum<Syntax>>(
                 "syntax",
                 |m: &Type| { &m.syntax },
                 |m: &mut Type| { &mut m.syntax },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Type>(
+            crate::reflect::MessageDescriptor::new_pb_name::<Type>(
                 "Type",
                 fields,
                 file_descriptor_proto()
@@ -379,12 +379,12 @@
     }
 
     fn default_instance() -> &'static Type {
-        static instance: ::protobuf::rt::LazyV2<Type> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<Type> = crate::rt::LazyV2::INIT;
         instance.get(Type::new)
     }
 }
 
-impl ::protobuf::Clear for Type {
+impl crate::Clear for Type {
     fn clear(&mut self) {
         self.name.clear();
         self.fields.clear();
@@ -398,13 +398,13 @@
 
 impl ::std::fmt::Debug for Type {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for Type {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for Type {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -419,19 +419,19 @@
     pub type_url: ::std::string::String,
     pub oneof_index: i32,
     pub packed: bool,
-    pub options: ::protobuf::RepeatedField<Option>,
+    pub options: crate::RepeatedField<Option>,
     pub json_name: ::std::string::String,
     pub default_value: ::std::string::String,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a Field {
     fn default() -> &'a Field {
-        <Field as ::protobuf::Message>::default_instance()
+        <Field as crate::Message>::default_instance()
     }
 }
 
@@ -578,18 +578,18 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_options(&mut self, v: ::protobuf::RepeatedField<Option>) {
+    pub fn set_options(&mut self, v: crate::RepeatedField<Option>) {
         self.options = v;
     }
 
     // Mutable pointer to the field.
-    pub fn mut_options(&mut self) -> &mut ::protobuf::RepeatedField<Option> {
+    pub fn mut_options(&mut self) -> &mut crate::RepeatedField<Option> {
         &mut self.options
     }
 
     // Take field
-    pub fn take_options(&mut self) -> ::protobuf::RepeatedField<Option> {
-        ::std::mem::replace(&mut self.options, ::protobuf::RepeatedField::new())
+    pub fn take_options(&mut self) -> crate::RepeatedField<Option> {
+        ::std::mem::replace(&mut self.options, crate::RepeatedField::new())
     }
 
     // string json_name = 10;
@@ -645,7 +645,7 @@
     }
 }
 
-impl ::protobuf::Message for Field {
+impl crate::Message for Field {
     fn is_initialized(&self) -> bool {
         for v in &self.options {
             if !v.is_initialized() {
@@ -655,54 +655,54 @@
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
         while !is.eof()? {
             let (field_number, wire_type) = is.read_tag_unpack()?;
             match field_number {
                 1 => {
-                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.kind, 1, &mut self.unknown_fields)?
+                    crate::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.kind, 1, &mut self.unknown_fields)?
                 },
                 2 => {
-                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.cardinality, 2, &mut self.unknown_fields)?
+                    crate::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.cardinality, 2, &mut self.unknown_fields)?
                 },
                 3 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_int32()?;
                     self.number = tmp;
                 },
                 4 => {
-                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
+                    crate::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
                 },
                 6 => {
-                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.type_url)?;
+                    crate::rt::read_singular_proto3_string_into(wire_type, is, &mut self.type_url)?;
                 },
                 7 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_int32()?;
                     self.oneof_index = tmp;
                 },
                 8 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_bool()?;
                     self.packed = tmp;
                 },
                 9 => {
-                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.options)?;
+                    crate::rt::read_repeated_message_into(wire_type, is, &mut self.options)?;
                 },
                 10 => {
-                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.json_name)?;
+                    crate::rt::read_singular_proto3_string_into(wire_type, is, &mut self.json_name)?;
                 },
                 11 => {
-                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.default_value)?;
+                    crate::rt::read_singular_proto3_string_into(wire_type, is, &mut self.default_value)?;
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -714,47 +714,47 @@
     fn compute_size(&self) -> u32 {
         let mut my_size = 0;
         if self.kind != Field_Kind::TYPE_UNKNOWN {
-            my_size += ::protobuf::rt::enum_size(1, self.kind);
+            my_size += crate::rt::enum_size(1, self.kind);
         }
         if self.cardinality != Field_Cardinality::CARDINALITY_UNKNOWN {
-            my_size += ::protobuf::rt::enum_size(2, self.cardinality);
+            my_size += crate::rt::enum_size(2, self.cardinality);
         }
         if self.number != 0 {
-            my_size += ::protobuf::rt::value_size(3, self.number, ::protobuf::wire_format::WireTypeVarint);
+            my_size += crate::rt::value_size(3, self.number, crate::wire_format::WireTypeVarint);
         }
         if !self.name.is_empty() {
-            my_size += ::protobuf::rt::string_size(4, &self.name);
+            my_size += crate::rt::string_size(4, &self.name);
         }
         if !self.type_url.is_empty() {
-            my_size += ::protobuf::rt::string_size(6, &self.type_url);
+            my_size += crate::rt::string_size(6, &self.type_url);
         }
         if self.oneof_index != 0 {
-            my_size += ::protobuf::rt::value_size(7, self.oneof_index, ::protobuf::wire_format::WireTypeVarint);
+            my_size += crate::rt::value_size(7, self.oneof_index, crate::wire_format::WireTypeVarint);
         }
         if self.packed != false {
             my_size += 2;
         }
         for value in &self.options {
             let len = value.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
         };
         if !self.json_name.is_empty() {
-            my_size += ::protobuf::rt::string_size(10, &self.json_name);
+            my_size += crate::rt::string_size(10, &self.json_name);
         }
         if !self.default_value.is_empty() {
-            my_size += ::protobuf::rt::string_size(11, &self.default_value);
+            my_size += crate::rt::string_size(11, &self.default_value);
         }
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         if self.kind != Field_Kind::TYPE_UNKNOWN {
-            os.write_enum(1, ::protobuf::ProtobufEnum::value(&self.kind))?;
+            os.write_enum(1, crate::ProtobufEnum::value(&self.kind))?;
         }
         if self.cardinality != Field_Cardinality::CARDINALITY_UNKNOWN {
-            os.write_enum(2, ::protobuf::ProtobufEnum::value(&self.cardinality))?;
+            os.write_enum(2, crate::ProtobufEnum::value(&self.cardinality))?;
         }
         if self.number != 0 {
             os.write_int32(3, self.number)?;
@@ -772,7 +772,7 @@
             os.write_bool(8, self.packed)?;
         }
         for v in &self.options {
-            os.write_tag(9, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(9, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         };
@@ -790,11 +790,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -808,7 +808,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -816,61 +816,61 @@
         Field::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<Field_Kind>>(
+            fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeEnum<Field_Kind>>(
                 "kind",
                 |m: &Field| { &m.kind },
                 |m: &mut Field| { &mut m.kind },
             ));
-            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<Field_Cardinality>>(
+            fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeEnum<Field_Cardinality>>(
                 "cardinality",
                 |m: &Field| { &m.cardinality },
                 |m: &mut Field| { &mut m.cardinality },
             ));
-            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
+            fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeInt32>(
                 "number",
                 |m: &Field| { &m.number },
                 |m: &mut Field| { &mut m.number },
             ));
-            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "name",
                 |m: &Field| { &m.name },
                 |m: &mut Field| { &mut m.name },
             ));
-            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "type_url",
                 |m: &Field| { &m.type_url },
                 |m: &mut Field| { &mut m.type_url },
             ));
-            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
+            fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeInt32>(
                 "oneof_index",
                 |m: &Field| { &m.oneof_index },
                 |m: &mut Field| { &mut m.oneof_index },
             ));
-            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
+            fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeBool>(
                 "packed",
                 |m: &Field| { &m.packed },
                 |m: &mut Field| { &mut m.packed },
             ));
-            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Option>>(
+            fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<Option>>(
                 "options",
                 |m: &Field| { &m.options },
                 |m: &mut Field| { &mut m.options },
             ));
-            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "json_name",
                 |m: &Field| { &m.json_name },
                 |m: &mut Field| { &mut m.json_name },
             ));
-            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "default_value",
                 |m: &Field| { &m.default_value },
                 |m: &mut Field| { &mut m.default_value },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Field>(
+            crate::reflect::MessageDescriptor::new_pb_name::<Field>(
                 "Field",
                 fields,
                 file_descriptor_proto()
@@ -879,12 +879,12 @@
     }
 
     fn default_instance() -> &'static Field {
-        static instance: ::protobuf::rt::LazyV2<Field> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<Field> = crate::rt::LazyV2::INIT;
         instance.get(Field::new)
     }
 }
 
-impl ::protobuf::Clear for Field {
+impl crate::Clear for Field {
     fn clear(&mut self) {
         self.kind = Field_Kind::TYPE_UNKNOWN;
         self.cardinality = Field_Cardinality::CARDINALITY_UNKNOWN;
@@ -902,13 +902,13 @@
 
 impl ::std::fmt::Debug for Field {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for Field {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for Field {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -936,7 +936,7 @@
     TYPE_SINT64 = 18,
 }
 
-impl ::protobuf::ProtobufEnum for Field_Kind {
+impl crate::ProtobufEnum for Field_Kind {
     fn value(&self) -> i32 {
         *self as i32
     }
@@ -991,10 +991,10 @@
         values
     }
 
-    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn enum_descriptor_static() -> &'static crate::reflect::EnumDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::EnumDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
-            ::protobuf::reflect::EnumDescriptor::new_pb_name::<Field_Kind>("Field.Kind", file_descriptor_proto())
+            crate::reflect::EnumDescriptor::new_pb_name::<Field_Kind>("Field.Kind", file_descriptor_proto())
         })
     }
 }
@@ -1008,9 +1008,9 @@
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for Field_Kind {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
+impl crate::reflect::ProtobufValue for Field_Kind {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Enum(crate::ProtobufEnum::descriptor(self))
     }
 }
 
@@ -1023,7 +1023,7 @@
     CARDINALITY_REPEATED = 3,
 }
 
-impl ::protobuf::ProtobufEnum for Field_Cardinality {
+impl crate::ProtobufEnum for Field_Cardinality {
     fn value(&self) -> i32 {
         *self as i32
     }
@@ -1048,10 +1048,10 @@
         values
     }
 
-    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn enum_descriptor_static() -> &'static crate::reflect::EnumDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::EnumDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
-            ::protobuf::reflect::EnumDescriptor::new_pb_name::<Field_Cardinality>("Field.Cardinality", file_descriptor_proto())
+            crate::reflect::EnumDescriptor::new_pb_name::<Field_Cardinality>("Field.Cardinality", file_descriptor_proto())
         })
     }
 }
@@ -1065,9 +1065,9 @@
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for Field_Cardinality {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
+impl crate::reflect::ProtobufValue for Field_Cardinality {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Enum(crate::ProtobufEnum::descriptor(self))
     }
 }
 
@@ -1076,20 +1076,20 @@
 pub struct Enum {
     // message fields
     pub name: ::std::string::String,
-    pub enumvalue: ::protobuf::RepeatedField<EnumValue>,
-    pub options: ::protobuf::RepeatedField<Option>,
-    pub source_context: ::protobuf::SingularPtrField<::protobuf::well_known_types::SourceContext>,
+    pub enumvalue: crate::RepeatedField<EnumValue>,
+    pub options: crate::RepeatedField<Option>,
+    pub source_context: crate::SingularPtrField<crate::well_known_types::SourceContext>,
     pub syntax: Syntax,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a Enum {
     fn default() -> &'a Enum {
-        <Enum as ::protobuf::Message>::default_instance()
+        <Enum as crate::Message>::default_instance()
     }
 }
 
@@ -1135,18 +1135,18 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_enumvalue(&mut self, v: ::protobuf::RepeatedField<EnumValue>) {
+    pub fn set_enumvalue(&mut self, v: crate::RepeatedField<EnumValue>) {
         self.enumvalue = v;
     }
 
     // Mutable pointer to the field.
-    pub fn mut_enumvalue(&mut self) -> &mut ::protobuf::RepeatedField<EnumValue> {
+    pub fn mut_enumvalue(&mut self) -> &mut crate::RepeatedField<EnumValue> {
         &mut self.enumvalue
     }
 
     // Take field
-    pub fn take_enumvalue(&mut self) -> ::protobuf::RepeatedField<EnumValue> {
-        ::std::mem::replace(&mut self.enumvalue, ::protobuf::RepeatedField::new())
+    pub fn take_enumvalue(&mut self) -> crate::RepeatedField<EnumValue> {
+        ::std::mem::replace(&mut self.enumvalue, crate::RepeatedField::new())
     }
 
     // repeated .google.protobuf.Option options = 3;
@@ -1160,25 +1160,25 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_options(&mut self, v: ::protobuf::RepeatedField<Option>) {
+    pub fn set_options(&mut self, v: crate::RepeatedField<Option>) {
         self.options = v;
     }
 
     // Mutable pointer to the field.
-    pub fn mut_options(&mut self) -> &mut ::protobuf::RepeatedField<Option> {
+    pub fn mut_options(&mut self) -> &mut crate::RepeatedField<Option> {
         &mut self.options
     }
 
     // Take field
-    pub fn take_options(&mut self) -> ::protobuf::RepeatedField<Option> {
-        ::std::mem::replace(&mut self.options, ::protobuf::RepeatedField::new())
+    pub fn take_options(&mut self) -> crate::RepeatedField<Option> {
+        ::std::mem::replace(&mut self.options, crate::RepeatedField::new())
     }
 
     // .google.protobuf.SourceContext source_context = 4;
 
 
-    pub fn get_source_context(&self) -> &::protobuf::well_known_types::SourceContext {
-        self.source_context.as_ref().unwrap_or_else(|| <::protobuf::well_known_types::SourceContext as ::protobuf::Message>::default_instance())
+    pub fn get_source_context(&self) -> &crate::well_known_types::SourceContext {
+        self.source_context.as_ref().unwrap_or_else(|| <crate::well_known_types::SourceContext as crate::Message>::default_instance())
     }
     pub fn clear_source_context(&mut self) {
         self.source_context.clear();
@@ -1189,13 +1189,13 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_source_context(&mut self, v: ::protobuf::well_known_types::SourceContext) {
-        self.source_context = ::protobuf::SingularPtrField::some(v);
+    pub fn set_source_context(&mut self, v: crate::well_known_types::SourceContext) {
+        self.source_context = crate::SingularPtrField::some(v);
     }
 
     // Mutable pointer to the field.
     // If field is not initialized, it is initialized with default value first.
-    pub fn mut_source_context(&mut self) -> &mut ::protobuf::well_known_types::SourceContext {
+    pub fn mut_source_context(&mut self) -> &mut crate::well_known_types::SourceContext {
         if self.source_context.is_none() {
             self.source_context.set_default();
         }
@@ -1203,8 +1203,8 @@
     }
 
     // Take field
-    pub fn take_source_context(&mut self) -> ::protobuf::well_known_types::SourceContext {
-        self.source_context.take().unwrap_or_else(|| ::protobuf::well_known_types::SourceContext::new())
+    pub fn take_source_context(&mut self) -> crate::well_known_types::SourceContext {
+        self.source_context.take().unwrap_or_else(|| crate::well_known_types::SourceContext::new())
     }
 
     // .google.protobuf.Syntax syntax = 5;
@@ -1223,7 +1223,7 @@
     }
 }
 
-impl ::protobuf::Message for Enum {
+impl crate::Message for Enum {
     fn is_initialized(&self) -> bool {
         for v in &self.enumvalue {
             if !v.is_initialized() {
@@ -1243,27 +1243,27 @@
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::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.name)?;
+                    crate::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
                 },
                 2 => {
-                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.enumvalue)?;
+                    crate::rt::read_repeated_message_into(wire_type, is, &mut self.enumvalue)?;
                 },
                 3 => {
-                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.options)?;
+                    crate::rt::read_repeated_message_into(wire_type, is, &mut self.options)?;
                 },
                 4 => {
-                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.source_context)?;
+                    crate::rt::read_singular_message_into(wire_type, is, &mut self.source_context)?;
                 },
                 5 => {
-                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.syntax, 5, &mut self.unknown_fields)?
+                    crate::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.syntax, 5, &mut self.unknown_fields)?
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -1275,49 +1275,49 @@
     fn compute_size(&self) -> u32 {
         let mut my_size = 0;
         if !self.name.is_empty() {
-            my_size += ::protobuf::rt::string_size(1, &self.name);
+            my_size += crate::rt::string_size(1, &self.name);
         }
         for value in &self.enumvalue {
             let len = value.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
         };
         for value in &self.options {
             let len = value.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
         };
         if let Some(ref v) = self.source_context.as_ref() {
             let len = v.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
         }
         if self.syntax != Syntax::SYNTAX_PROTO2 {
-            my_size += ::protobuf::rt::enum_size(5, self.syntax);
+            my_size += crate::rt::enum_size(5, self.syntax);
         }
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         if !self.name.is_empty() {
             os.write_string(1, &self.name)?;
         }
         for v in &self.enumvalue {
-            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(2, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         };
         for v in &self.options {
-            os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(3, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         };
         if let Some(ref v) = self.source_context.as_ref() {
-            os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(4, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         }
         if self.syntax != Syntax::SYNTAX_PROTO2 {
-            os.write_enum(5, ::protobuf::ProtobufEnum::value(&self.syntax))?;
+            os.write_enum(5, crate::ProtobufEnum::value(&self.syntax))?;
         }
         os.write_unknown_fields(self.get_unknown_fields())?;
         ::std::result::Result::Ok(())
@@ -1327,11 +1327,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -1345,7 +1345,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -1353,36 +1353,36 @@
         Enum::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "name",
                 |m: &Enum| { &m.name },
                 |m: &mut Enum| { &mut m.name },
             ));
-            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<EnumValue>>(
+            fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<EnumValue>>(
                 "enumvalue",
                 |m: &Enum| { &m.enumvalue },
                 |m: &mut Enum| { &mut m.enumvalue },
             ));
-            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Option>>(
+            fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<Option>>(
                 "options",
                 |m: &Enum| { &m.options },
                 |m: &mut Enum| { &mut m.options },
             ));
-            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::SourceContext>>(
+            fields.push(crate::reflect::accessor::make_singular_ptr_field_accessor::<_, crate::types::ProtobufTypeMessage<crate::well_known_types::SourceContext>>(
                 "source_context",
                 |m: &Enum| { &m.source_context },
                 |m: &mut Enum| { &mut m.source_context },
             ));
-            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<Syntax>>(
+            fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeEnum<Syntax>>(
                 "syntax",
                 |m: &Enum| { &m.syntax },
                 |m: &mut Enum| { &mut m.syntax },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Enum>(
+            crate::reflect::MessageDescriptor::new_pb_name::<Enum>(
                 "Enum",
                 fields,
                 file_descriptor_proto()
@@ -1391,12 +1391,12 @@
     }
 
     fn default_instance() -> &'static Enum {
-        static instance: ::protobuf::rt::LazyV2<Enum> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<Enum> = crate::rt::LazyV2::INIT;
         instance.get(Enum::new)
     }
 }
 
-impl ::protobuf::Clear for Enum {
+impl crate::Clear for Enum {
     fn clear(&mut self) {
         self.name.clear();
         self.enumvalue.clear();
@@ -1409,13 +1409,13 @@
 
 impl ::std::fmt::Debug for Enum {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for Enum {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for Enum {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -1425,17 +1425,17 @@
     // message fields
     pub name: ::std::string::String,
     pub number: i32,
-    pub options: ::protobuf::RepeatedField<Option>,
+    pub options: crate::RepeatedField<Option>,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a EnumValue {
     fn default() -> &'a EnumValue {
-        <EnumValue as ::protobuf::Message>::default_instance()
+        <EnumValue as crate::Message>::default_instance()
     }
 }
 
@@ -1496,22 +1496,22 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_options(&mut self, v: ::protobuf::RepeatedField<Option>) {
+    pub fn set_options(&mut self, v: crate::RepeatedField<Option>) {
         self.options = v;
     }
 
     // Mutable pointer to the field.
-    pub fn mut_options(&mut self) -> &mut ::protobuf::RepeatedField<Option> {
+    pub fn mut_options(&mut self) -> &mut crate::RepeatedField<Option> {
         &mut self.options
     }
 
     // Take field
-    pub fn take_options(&mut self) -> ::protobuf::RepeatedField<Option> {
-        ::std::mem::replace(&mut self.options, ::protobuf::RepeatedField::new())
+    pub fn take_options(&mut self) -> crate::RepeatedField<Option> {
+        ::std::mem::replace(&mut self.options, crate::RepeatedField::new())
     }
 }
 
-impl ::protobuf::Message for EnumValue {
+impl crate::Message for EnumValue {
     fn is_initialized(&self) -> bool {
         for v in &self.options {
             if !v.is_initialized() {
@@ -1521,25 +1521,25 @@
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::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.name)?;
+                    crate::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
                 },
                 2 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_int32()?;
                     self.number = tmp;
                 },
                 3 => {
-                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.options)?;
+                    crate::rt::read_repeated_message_into(wire_type, is, &mut self.options)?;
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -1551,21 +1551,21 @@
     fn compute_size(&self) -> u32 {
         let mut my_size = 0;
         if !self.name.is_empty() {
-            my_size += ::protobuf::rt::string_size(1, &self.name);
+            my_size += crate::rt::string_size(1, &self.name);
         }
         if self.number != 0 {
-            my_size += ::protobuf::rt::value_size(2, self.number, ::protobuf::wire_format::WireTypeVarint);
+            my_size += crate::rt::value_size(2, self.number, crate::wire_format::WireTypeVarint);
         }
         for value in &self.options {
             let len = value.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
         };
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         if !self.name.is_empty() {
             os.write_string(1, &self.name)?;
         }
@@ -1573,7 +1573,7 @@
             os.write_int32(2, self.number)?;
         }
         for v in &self.options {
-            os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(3, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         };
@@ -1585,11 +1585,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -1603,7 +1603,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -1611,26 +1611,26 @@
         EnumValue::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "name",
                 |m: &EnumValue| { &m.name },
                 |m: &mut EnumValue| { &mut m.name },
             ));
-            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
+            fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeInt32>(
                 "number",
                 |m: &EnumValue| { &m.number },
                 |m: &mut EnumValue| { &mut m.number },
             ));
-            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Option>>(
+            fields.push(crate::reflect::accessor::make_repeated_field_accessor::<_, crate::types::ProtobufTypeMessage<Option>>(
                 "options",
                 |m: &EnumValue| { &m.options },
                 |m: &mut EnumValue| { &mut m.options },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<EnumValue>(
+            crate::reflect::MessageDescriptor::new_pb_name::<EnumValue>(
                 "EnumValue",
                 fields,
                 file_descriptor_proto()
@@ -1639,12 +1639,12 @@
     }
 
     fn default_instance() -> &'static EnumValue {
-        static instance: ::protobuf::rt::LazyV2<EnumValue> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<EnumValue> = crate::rt::LazyV2::INIT;
         instance.get(EnumValue::new)
     }
 }
 
-impl ::protobuf::Clear for EnumValue {
+impl crate::Clear for EnumValue {
     fn clear(&mut self) {
         self.name.clear();
         self.number = 0;
@@ -1655,13 +1655,13 @@
 
 impl ::std::fmt::Debug for EnumValue {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for EnumValue {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for EnumValue {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -1670,17 +1670,17 @@
 pub struct Option {
     // message fields
     pub name: ::std::string::String,
-    pub value: ::protobuf::SingularPtrField<::protobuf::well_known_types::Any>,
+    pub value: crate::SingularPtrField<crate::well_known_types::Any>,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a Option {
     fn default() -> &'a Option {
-        <Option as ::protobuf::Message>::default_instance()
+        <Option as crate::Message>::default_instance()
     }
 }
 
@@ -1718,8 +1718,8 @@
     // .google.protobuf.Any value = 2;
 
 
-    pub fn get_value(&self) -> &::protobuf::well_known_types::Any {
-        self.value.as_ref().unwrap_or_else(|| <::protobuf::well_known_types::Any as ::protobuf::Message>::default_instance())
+    pub fn get_value(&self) -> &crate::well_known_types::Any {
+        self.value.as_ref().unwrap_or_else(|| <crate::well_known_types::Any as crate::Message>::default_instance())
     }
     pub fn clear_value(&mut self) {
         self.value.clear();
@@ -1730,13 +1730,13 @@
     }
 
     // Param is passed by value, moved
-    pub fn set_value(&mut self, v: ::protobuf::well_known_types::Any) {
-        self.value = ::protobuf::SingularPtrField::some(v);
+    pub fn set_value(&mut self, v: crate::well_known_types::Any) {
+        self.value = crate::SingularPtrField::some(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 ::protobuf::well_known_types::Any {
+    pub fn mut_value(&mut self) -> &mut crate::well_known_types::Any {
         if self.value.is_none() {
             self.value.set_default();
         }
@@ -1744,12 +1744,12 @@
     }
 
     // Take field
-    pub fn take_value(&mut self) -> ::protobuf::well_known_types::Any {
-        self.value.take().unwrap_or_else(|| ::protobuf::well_known_types::Any::new())
+    pub fn take_value(&mut self) -> crate::well_known_types::Any {
+        self.value.take().unwrap_or_else(|| crate::well_known_types::Any::new())
     }
 }
 
-impl ::protobuf::Message for Option {
+impl crate::Message for Option {
     fn is_initialized(&self) -> bool {
         for v in &self.value {
             if !v.is_initialized() {
@@ -1759,18 +1759,18 @@
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::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.name)?;
+                    crate::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
                 },
                 2 => {
-                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.value)?;
+                    crate::rt::read_singular_message_into(wire_type, is, &mut self.value)?;
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -1782,23 +1782,23 @@
     fn compute_size(&self) -> u32 {
         let mut my_size = 0;
         if !self.name.is_empty() {
-            my_size += ::protobuf::rt::string_size(1, &self.name);
+            my_size += crate::rt::string_size(1, &self.name);
         }
         if let Some(ref v) = self.value.as_ref() {
             let len = v.compute_size();
-            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
+            my_size += 1 + crate::rt::compute_raw_varint32_size(len) + len;
         }
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         if !self.name.is_empty() {
             os.write_string(1, &self.name)?;
         }
         if let Some(ref v) = self.value.as_ref() {
-            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
+            os.write_tag(2, crate::wire_format::WireTypeLengthDelimited)?;
             os.write_raw_varint32(v.get_cached_size())?;
             v.write_to_with_cached_sizes(os)?;
         }
@@ -1810,11 +1810,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -1828,7 +1828,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -1836,21 +1836,21 @@
         Option::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "name",
                 |m: &Option| { &m.name },
                 |m: &mut Option| { &mut m.name },
             ));
-            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Any>>(
+            fields.push(crate::reflect::accessor::make_singular_ptr_field_accessor::<_, crate::types::ProtobufTypeMessage<crate::well_known_types::Any>>(
                 "value",
                 |m: &Option| { &m.value },
                 |m: &mut Option| { &mut m.value },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Option>(
+            crate::reflect::MessageDescriptor::new_pb_name::<Option>(
                 "Option",
                 fields,
                 file_descriptor_proto()
@@ -1859,12 +1859,12 @@
     }
 
     fn default_instance() -> &'static Option {
-        static instance: ::protobuf::rt::LazyV2<Option> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<Option> = crate::rt::LazyV2::INIT;
         instance.get(Option::new)
     }
 }
 
-impl ::protobuf::Clear for Option {
+impl crate::Clear for Option {
     fn clear(&mut self) {
         self.name.clear();
         self.value.clear();
@@ -1874,13 +1874,13 @@
 
 impl ::std::fmt::Debug for Option {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for Option {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for Option {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -1891,7 +1891,7 @@
     SYNTAX_PROTO3 = 1,
 }
 
-impl ::protobuf::ProtobufEnum for Syntax {
+impl crate::ProtobufEnum for Syntax {
     fn value(&self) -> i32 {
         *self as i32
     }
@@ -1912,10 +1912,10 @@
         values
     }
 
-    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn enum_descriptor_static() -> &'static crate::reflect::EnumDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::EnumDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
-            ::protobuf::reflect::EnumDescriptor::new_pb_name::<Syntax>("Syntax", file_descriptor_proto())
+            crate::reflect::EnumDescriptor::new_pb_name::<Syntax>("Syntax", file_descriptor_proto())
         })
     }
 }
@@ -1929,9 +1929,9 @@
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for Syntax {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
+impl crate::reflect::ProtobufValue for Syntax {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Enum(crate::ProtobufEnum::descriptor(self))
     }
 }
 
@@ -2210,13 +2210,13 @@
     to3\
 ";
 
-static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;
+static file_descriptor_proto_lazy: crate::rt::LazyV2<crate::descriptor::FileDescriptorProto> = crate::rt::LazyV2::INIT;
 
-fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
-    ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap()
+fn parse_descriptor_proto() -> crate::descriptor::FileDescriptorProto {
+    crate::parse_from_bytes(file_descriptor_proto_data).unwrap()
 }
 
-pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
+pub fn file_descriptor_proto() -> &'static crate::descriptor::FileDescriptorProto {
     file_descriptor_proto_lazy.get(|| {
         parse_descriptor_proto()
     })
diff --git a/src/well_known_types/wrappers.rs b/src/well_known_types/wrappers.rs
index c0ff80e..0ec90b2 100644
--- a/src/well_known_types/wrappers.rs
+++ b/src/well_known_types/wrappers.rs
@@ -1,4 +1,4 @@
-// This file is generated by rust-protobuf 2.16.0-pre. Do not edit
+// This file is generated by rust-protobuf 2.17.0-pre. Do not edit
 // @generated
 
 // https://github.com/rust-lang/rust-clippy/issues/702
@@ -26,14 +26,14 @@
     pub value: f64,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a DoubleValue {
     fn default() -> &'a DoubleValue {
-        <DoubleValue as ::protobuf::Message>::default_instance()
+        <DoubleValue as crate::Message>::default_instance()
     }
 }
 
@@ -58,24 +58,24 @@
     }
 }
 
-impl ::protobuf::Message for DoubleValue {
+impl crate::Message for DoubleValue {
     fn is_initialized(&self) -> bool {
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
         while !is.eof()? {
             let (field_number, wire_type) = is.read_tag_unpack()?;
             match field_number {
                 1 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeFixed64 {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_double()?;
                     self.value = tmp;
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -89,12 +89,12 @@
         if self.value != 0. {
             my_size += 9;
         }
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         if self.value != 0. {
             os.write_double(1, self.value)?;
         }
@@ -106,11 +106,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -124,7 +124,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -132,16 +132,16 @@
         DoubleValue::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeDouble>(
+            fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeDouble>(
                 "value",
                 |m: &DoubleValue| { &m.value },
                 |m: &mut DoubleValue| { &mut m.value },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<DoubleValue>(
+            crate::reflect::MessageDescriptor::new_pb_name::<DoubleValue>(
                 "DoubleValue",
                 fields,
                 file_descriptor_proto()
@@ -150,12 +150,12 @@
     }
 
     fn default_instance() -> &'static DoubleValue {
-        static instance: ::protobuf::rt::LazyV2<DoubleValue> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<DoubleValue> = crate::rt::LazyV2::INIT;
         instance.get(DoubleValue::new)
     }
 }
 
-impl ::protobuf::Clear for DoubleValue {
+impl crate::Clear for DoubleValue {
     fn clear(&mut self) {
         self.value = 0.;
         self.unknown_fields.clear();
@@ -164,13 +164,13 @@
 
 impl ::std::fmt::Debug for DoubleValue {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for DoubleValue {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for DoubleValue {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -181,14 +181,14 @@
     pub value: f32,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a FloatValue {
     fn default() -> &'a FloatValue {
-        <FloatValue as ::protobuf::Message>::default_instance()
+        <FloatValue as crate::Message>::default_instance()
     }
 }
 
@@ -213,24 +213,24 @@
     }
 }
 
-impl ::protobuf::Message for FloatValue {
+impl crate::Message for FloatValue {
     fn is_initialized(&self) -> bool {
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::ProtobufResult<()> {
         while !is.eof()? {
             let (field_number, wire_type) = is.read_tag_unpack()?;
             match field_number {
                 1 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeFixed32 {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    if wire_type != crate::wire_format::WireTypeFixed32 {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_float()?;
                     self.value = tmp;
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -244,12 +244,12 @@
         if self.value != 0. {
             my_size += 5;
         }
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         if self.value != 0. {
             os.write_float(1, self.value)?;
         }
@@ -261,11 +261,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -279,7 +279,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -287,16 +287,16 @@
         FloatValue::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeFloat>(
+            fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeFloat>(
                 "value",
                 |m: &FloatValue| { &m.value },
                 |m: &mut FloatValue| { &mut m.value },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<FloatValue>(
+            crate::reflect::MessageDescriptor::new_pb_name::<FloatValue>(
                 "FloatValue",
                 fields,
                 file_descriptor_proto()
@@ -305,12 +305,12 @@
     }
 
     fn default_instance() -> &'static FloatValue {
-        static instance: ::protobuf::rt::LazyV2<FloatValue> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<FloatValue> = crate::rt::LazyV2::INIT;
         instance.get(FloatValue::new)
     }
 }
 
-impl ::protobuf::Clear for FloatValue {
+impl crate::Clear for FloatValue {
     fn clear(&mut self) {
         self.value = 0.;
         self.unknown_fields.clear();
@@ -319,13 +319,13 @@
 
 impl ::std::fmt::Debug for FloatValue {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for FloatValue {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for FloatValue {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -336,14 +336,14 @@
     pub value: i64,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a Int64Value {
     fn default() -> &'a Int64Value {
-        <Int64Value as ::protobuf::Message>::default_instance()
+        <Int64Value as crate::Message>::default_instance()
     }
 }
 
@@ -368,24 +368,24 @@
     }
 }
 
-impl ::protobuf::Message for Int64Value {
+impl crate::Message for Int64Value {
     fn is_initialized(&self) -> bool {
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::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));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_int64()?;
                     self.value = tmp;
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -397,14 +397,14 @@
     fn compute_size(&self) -> u32 {
         let mut my_size = 0;
         if self.value != 0 {
-            my_size += ::protobuf::rt::value_size(1, self.value, ::protobuf::wire_format::WireTypeVarint);
+            my_size += crate::rt::value_size(1, self.value, crate::wire_format::WireTypeVarint);
         }
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         if self.value != 0 {
             os.write_int64(1, self.value)?;
         }
@@ -416,11 +416,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -434,7 +434,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -442,16 +442,16 @@
         Int64Value::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
+            fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeInt64>(
                 "value",
                 |m: &Int64Value| { &m.value },
                 |m: &mut Int64Value| { &mut m.value },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Int64Value>(
+            crate::reflect::MessageDescriptor::new_pb_name::<Int64Value>(
                 "Int64Value",
                 fields,
                 file_descriptor_proto()
@@ -460,12 +460,12 @@
     }
 
     fn default_instance() -> &'static Int64Value {
-        static instance: ::protobuf::rt::LazyV2<Int64Value> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<Int64Value> = crate::rt::LazyV2::INIT;
         instance.get(Int64Value::new)
     }
 }
 
-impl ::protobuf::Clear for Int64Value {
+impl crate::Clear for Int64Value {
     fn clear(&mut self) {
         self.value = 0;
         self.unknown_fields.clear();
@@ -474,13 +474,13 @@
 
 impl ::std::fmt::Debug for Int64Value {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for Int64Value {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for Int64Value {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -491,14 +491,14 @@
     pub value: u64,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a UInt64Value {
     fn default() -> &'a UInt64Value {
-        <UInt64Value as ::protobuf::Message>::default_instance()
+        <UInt64Value as crate::Message>::default_instance()
     }
 }
 
@@ -523,24 +523,24 @@
     }
 }
 
-impl ::protobuf::Message for UInt64Value {
+impl crate::Message for UInt64Value {
     fn is_initialized(&self) -> bool {
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::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));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_uint64()?;
                     self.value = tmp;
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -552,14 +552,14 @@
     fn compute_size(&self) -> u32 {
         let mut my_size = 0;
         if self.value != 0 {
-            my_size += ::protobuf::rt::value_size(1, self.value, ::protobuf::wire_format::WireTypeVarint);
+            my_size += crate::rt::value_size(1, self.value, crate::wire_format::WireTypeVarint);
         }
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         if self.value != 0 {
             os.write_uint64(1, self.value)?;
         }
@@ -571,11 +571,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -589,7 +589,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -597,16 +597,16 @@
         UInt64Value::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
+            fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeUint64>(
                 "value",
                 |m: &UInt64Value| { &m.value },
                 |m: &mut UInt64Value| { &mut m.value },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<UInt64Value>(
+            crate::reflect::MessageDescriptor::new_pb_name::<UInt64Value>(
                 "UInt64Value",
                 fields,
                 file_descriptor_proto()
@@ -615,12 +615,12 @@
     }
 
     fn default_instance() -> &'static UInt64Value {
-        static instance: ::protobuf::rt::LazyV2<UInt64Value> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<UInt64Value> = crate::rt::LazyV2::INIT;
         instance.get(UInt64Value::new)
     }
 }
 
-impl ::protobuf::Clear for UInt64Value {
+impl crate::Clear for UInt64Value {
     fn clear(&mut self) {
         self.value = 0;
         self.unknown_fields.clear();
@@ -629,13 +629,13 @@
 
 impl ::std::fmt::Debug for UInt64Value {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for UInt64Value {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for UInt64Value {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -646,14 +646,14 @@
     pub value: i32,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a Int32Value {
     fn default() -> &'a Int32Value {
-        <Int32Value as ::protobuf::Message>::default_instance()
+        <Int32Value as crate::Message>::default_instance()
     }
 }
 
@@ -678,24 +678,24 @@
     }
 }
 
-impl ::protobuf::Message for Int32Value {
+impl crate::Message for Int32Value {
     fn is_initialized(&self) -> bool {
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::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));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_int32()?;
                     self.value = tmp;
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -707,14 +707,14 @@
     fn compute_size(&self) -> u32 {
         let mut my_size = 0;
         if self.value != 0 {
-            my_size += ::protobuf::rt::value_size(1, self.value, ::protobuf::wire_format::WireTypeVarint);
+            my_size += crate::rt::value_size(1, self.value, crate::wire_format::WireTypeVarint);
         }
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         if self.value != 0 {
             os.write_int32(1, self.value)?;
         }
@@ -726,11 +726,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -744,7 +744,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -752,16 +752,16 @@
         Int32Value::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
+            fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeInt32>(
                 "value",
                 |m: &Int32Value| { &m.value },
                 |m: &mut Int32Value| { &mut m.value },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Int32Value>(
+            crate::reflect::MessageDescriptor::new_pb_name::<Int32Value>(
                 "Int32Value",
                 fields,
                 file_descriptor_proto()
@@ -770,12 +770,12 @@
     }
 
     fn default_instance() -> &'static Int32Value {
-        static instance: ::protobuf::rt::LazyV2<Int32Value> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<Int32Value> = crate::rt::LazyV2::INIT;
         instance.get(Int32Value::new)
     }
 }
 
-impl ::protobuf::Clear for Int32Value {
+impl crate::Clear for Int32Value {
     fn clear(&mut self) {
         self.value = 0;
         self.unknown_fields.clear();
@@ -784,13 +784,13 @@
 
 impl ::std::fmt::Debug for Int32Value {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for Int32Value {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for Int32Value {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -801,14 +801,14 @@
     pub value: u32,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a UInt32Value {
     fn default() -> &'a UInt32Value {
-        <UInt32Value as ::protobuf::Message>::default_instance()
+        <UInt32Value as crate::Message>::default_instance()
     }
 }
 
@@ -833,24 +833,24 @@
     }
 }
 
-impl ::protobuf::Message for UInt32Value {
+impl crate::Message for UInt32Value {
     fn is_initialized(&self) -> bool {
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::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));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_uint32()?;
                     self.value = tmp;
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -862,14 +862,14 @@
     fn compute_size(&self) -> u32 {
         let mut my_size = 0;
         if self.value != 0 {
-            my_size += ::protobuf::rt::value_size(1, self.value, ::protobuf::wire_format::WireTypeVarint);
+            my_size += crate::rt::value_size(1, self.value, crate::wire_format::WireTypeVarint);
         }
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         if self.value != 0 {
             os.write_uint32(1, self.value)?;
         }
@@ -881,11 +881,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -899,7 +899,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -907,16 +907,16 @@
         UInt32Value::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
+            fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeUint32>(
                 "value",
                 |m: &UInt32Value| { &m.value },
                 |m: &mut UInt32Value| { &mut m.value },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<UInt32Value>(
+            crate::reflect::MessageDescriptor::new_pb_name::<UInt32Value>(
                 "UInt32Value",
                 fields,
                 file_descriptor_proto()
@@ -925,12 +925,12 @@
     }
 
     fn default_instance() -> &'static UInt32Value {
-        static instance: ::protobuf::rt::LazyV2<UInt32Value> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<UInt32Value> = crate::rt::LazyV2::INIT;
         instance.get(UInt32Value::new)
     }
 }
 
-impl ::protobuf::Clear for UInt32Value {
+impl crate::Clear for UInt32Value {
     fn clear(&mut self) {
         self.value = 0;
         self.unknown_fields.clear();
@@ -939,13 +939,13 @@
 
 impl ::std::fmt::Debug for UInt32Value {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for UInt32Value {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for UInt32Value {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -956,14 +956,14 @@
     pub value: bool,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a BoolValue {
     fn default() -> &'a BoolValue {
-        <BoolValue as ::protobuf::Message>::default_instance()
+        <BoolValue as crate::Message>::default_instance()
     }
 }
 
@@ -988,24 +988,24 @@
     }
 }
 
-impl ::protobuf::Message for BoolValue {
+impl crate::Message for BoolValue {
     fn is_initialized(&self) -> bool {
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::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));
+                    if wire_type != crate::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(crate::rt::unexpected_wire_type(wire_type));
                     }
                     let tmp = is.read_bool()?;
                     self.value = tmp;
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -1019,12 +1019,12 @@
         if self.value != false {
             my_size += 2;
         }
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         if self.value != false {
             os.write_bool(1, self.value)?;
         }
@@ -1036,11 +1036,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -1054,7 +1054,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -1062,16 +1062,16 @@
         BoolValue::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
+            fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeBool>(
                 "value",
                 |m: &BoolValue| { &m.value },
                 |m: &mut BoolValue| { &mut m.value },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<BoolValue>(
+            crate::reflect::MessageDescriptor::new_pb_name::<BoolValue>(
                 "BoolValue",
                 fields,
                 file_descriptor_proto()
@@ -1080,12 +1080,12 @@
     }
 
     fn default_instance() -> &'static BoolValue {
-        static instance: ::protobuf::rt::LazyV2<BoolValue> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<BoolValue> = crate::rt::LazyV2::INIT;
         instance.get(BoolValue::new)
     }
 }
 
-impl ::protobuf::Clear for BoolValue {
+impl crate::Clear for BoolValue {
     fn clear(&mut self) {
         self.value = false;
         self.unknown_fields.clear();
@@ -1094,13 +1094,13 @@
 
 impl ::std::fmt::Debug for BoolValue {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for BoolValue {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for BoolValue {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -1111,14 +1111,14 @@
     pub value: ::std::string::String,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a StringValue {
     fn default() -> &'a StringValue {
-        <StringValue as ::protobuf::Message>::default_instance()
+        <StringValue as crate::Message>::default_instance()
     }
 }
 
@@ -1154,20 +1154,20 @@
     }
 }
 
-impl ::protobuf::Message for StringValue {
+impl crate::Message for StringValue {
     fn is_initialized(&self) -> bool {
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::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.value)?;
+                    crate::rt::read_singular_proto3_string_into(wire_type, is, &mut self.value)?;
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -1179,14 +1179,14 @@
     fn compute_size(&self) -> u32 {
         let mut my_size = 0;
         if !self.value.is_empty() {
-            my_size += ::protobuf::rt::string_size(1, &self.value);
+            my_size += crate::rt::string_size(1, &self.value);
         }
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         if !self.value.is_empty() {
             os.write_string(1, &self.value)?;
         }
@@ -1198,11 +1198,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -1216,7 +1216,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -1224,16 +1224,16 @@
         StringValue::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
+            fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeString>(
                 "value",
                 |m: &StringValue| { &m.value },
                 |m: &mut StringValue| { &mut m.value },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<StringValue>(
+            crate::reflect::MessageDescriptor::new_pb_name::<StringValue>(
                 "StringValue",
                 fields,
                 file_descriptor_proto()
@@ -1242,12 +1242,12 @@
     }
 
     fn default_instance() -> &'static StringValue {
-        static instance: ::protobuf::rt::LazyV2<StringValue> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<StringValue> = crate::rt::LazyV2::INIT;
         instance.get(StringValue::new)
     }
 }
 
-impl ::protobuf::Clear for StringValue {
+impl crate::Clear for StringValue {
     fn clear(&mut self) {
         self.value.clear();
         self.unknown_fields.clear();
@@ -1256,13 +1256,13 @@
 
 impl ::std::fmt::Debug for StringValue {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for StringValue {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for StringValue {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -1273,14 +1273,14 @@
     pub value: ::std::vec::Vec<u8>,
     // special fields
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub unknown_fields: ::protobuf::UnknownFields,
+    pub unknown_fields: crate::UnknownFields,
     #[cfg_attr(feature = "with-serde", serde(skip))]
-    pub cached_size: ::protobuf::CachedSize,
+    pub cached_size: crate::CachedSize,
 }
 
 impl<'a> ::std::default::Default for &'a BytesValue {
     fn default() -> &'a BytesValue {
-        <BytesValue as ::protobuf::Message>::default_instance()
+        <BytesValue as crate::Message>::default_instance()
     }
 }
 
@@ -1316,20 +1316,20 @@
     }
 }
 
-impl ::protobuf::Message for BytesValue {
+impl crate::Message for BytesValue {
     fn is_initialized(&self) -> bool {
         true
     }
 
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
+    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::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.value)?;
+                    crate::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.value)?;
                 },
                 _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                    crate::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
             };
         }
@@ -1341,14 +1341,14 @@
     fn compute_size(&self) -> u32 {
         let mut my_size = 0;
         if !self.value.is_empty() {
-            my_size += ::protobuf::rt::bytes_size(1, &self.value);
+            my_size += crate::rt::bytes_size(1, &self.value);
         }
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        my_size += crate::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<()> {
+    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::ProtobufResult<()> {
         if !self.value.is_empty() {
             os.write_bytes(1, &self.value)?;
         }
@@ -1360,11 +1360,11 @@
         self.cached_size.get()
     }
 
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+    fn get_unknown_fields(&self) -> &crate::UnknownFields {
         &self.unknown_fields
     }
 
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+    fn mut_unknown_fields(&mut self) -> &mut crate::UnknownFields {
         &mut self.unknown_fields
     }
 
@@ -1378,7 +1378,7 @@
         self
     }
 
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+    fn descriptor(&self) -> &'static crate::reflect::MessageDescriptor {
         Self::descriptor_static()
     }
 
@@ -1386,16 +1386,16 @@
         BytesValue::new()
     }
 
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
+    fn descriptor_static() -> &'static crate::reflect::MessageDescriptor {
+        static descriptor: crate::rt::LazyV2<crate::reflect::MessageDescriptor> = crate::rt::LazyV2::INIT;
         descriptor.get(|| {
             let mut fields = ::std::vec::Vec::new();
-            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
+            fields.push(crate::reflect::accessor::make_simple_field_accessor::<_, crate::types::ProtobufTypeBytes>(
                 "value",
                 |m: &BytesValue| { &m.value },
                 |m: &mut BytesValue| { &mut m.value },
             ));
-            ::protobuf::reflect::MessageDescriptor::new_pb_name::<BytesValue>(
+            crate::reflect::MessageDescriptor::new_pb_name::<BytesValue>(
                 "BytesValue",
                 fields,
                 file_descriptor_proto()
@@ -1404,12 +1404,12 @@
     }
 
     fn default_instance() -> &'static BytesValue {
-        static instance: ::protobuf::rt::LazyV2<BytesValue> = ::protobuf::rt::LazyV2::INIT;
+        static instance: crate::rt::LazyV2<BytesValue> = crate::rt::LazyV2::INIT;
         instance.get(BytesValue::new)
     }
 }
 
-impl ::protobuf::Clear for BytesValue {
+impl crate::Clear for BytesValue {
     fn clear(&mut self) {
         self.value.clear();
         self.unknown_fields.clear();
@@ -1418,13 +1418,13 @@
 
 impl ::std::fmt::Debug for BytesValue {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
+        crate::text_format::fmt(self, f)
     }
 }
 
-impl ::protobuf::reflect::ProtobufValue for BytesValue {
-    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
-        ::protobuf::reflect::ReflectValueRef::Message(self)
+impl crate::reflect::ProtobufValue for BytesValue {
+    fn as_ref(&self) -> crate::reflect::ReflectValueRef {
+        crate::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -1543,13 +1543,13 @@
     b\x06proto3\
 ";
 
-static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;
+static file_descriptor_proto_lazy: crate::rt::LazyV2<crate::descriptor::FileDescriptorProto> = crate::rt::LazyV2::INIT;
 
-fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
-    ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap()
+fn parse_descriptor_proto() -> crate::descriptor::FileDescriptorProto {
+    crate::parse_from_bytes(file_descriptor_proto_data).unwrap()
 }
 
-pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
+pub fn file_descriptor_proto() -> &'static crate::descriptor::FileDescriptorProto {
     file_descriptor_proto_lazy.get(|| {
         parse_descriptor_proto()
     })