protobuf/
descriptor.rs

Help
1// This file is generated by rust-protobuf 4.0.0-alpha.0. Do not edit
2// .proto file is parsed by protoc --rs_out=...
3// @generated
4
5// https://github.com/rust-lang/rust-clippy/issues/702
6#![allow(unknown_lints)]
7#![allow(clippy::all)]
8
9#![allow(unused_attributes)]
10#![cfg_attr(rustfmt, rustfmt::skip)]
11
12#![allow(dead_code)]
13#![allow(missing_docs)]
14#![allow(non_camel_case_types)]
15#![allow(non_snake_case)]
16#![allow(non_upper_case_globals)]
17#![allow(trivial_casts)]
18#![allow(unused_results)]
19#![allow(unused_mut)]
20
21//! Generated file from `google/protobuf/descriptor.proto`
22
23///  The protocol compiler can output a FileDescriptorSet containing the .proto
24///  files it parses.
25// @@protoc_insertion_point(message:google.protobuf.FileDescriptorSet)
26#[derive(PartialEq,Clone,Default,Debug)]
27pub struct FileDescriptorSet {
28    // message fields
29    // @@protoc_insertion_point(field:google.protobuf.FileDescriptorSet.file)
30    pub file: ::std::vec::Vec<FileDescriptorProto>,
31    // special fields
32    // @@protoc_insertion_point(special_field:google.protobuf.FileDescriptorSet.special_fields)
33    pub special_fields: crate::SpecialFields,
34}
35
36impl<'a> ::std::default::Default for &'a FileDescriptorSet {
37    fn default() -> &'a FileDescriptorSet {
38        <FileDescriptorSet as crate::Message>::default_instance()
39    }
40}
41
42impl FileDescriptorSet {
43    pub fn new() -> FileDescriptorSet {
44        ::std::default::Default::default()
45    }
46
47    fn generated_message_descriptor_data() -> crate::reflect::GeneratedMessageDescriptorData {
48        let mut fields = ::std::vec::Vec::with_capacity(1);
49        let mut oneofs = ::std::vec::Vec::with_capacity(0);
50        fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
51            "file",
52            |m: &FileDescriptorSet| { &m.file },
53            |m: &mut FileDescriptorSet| { &mut m.file },
54        ));
55        crate::reflect::GeneratedMessageDescriptorData::new_2::<FileDescriptorSet>(
56            "FileDescriptorSet",
57            fields,
58            oneofs,
59        )
60    }
61}
62
63impl crate::Message for FileDescriptorSet {
64    const NAME: &'static str = "FileDescriptorSet";
65
66    fn is_initialized(&self) -> bool {
67        for v in &self.file {
68            if !v.is_initialized() {
69                return false;
70            }
71        };
72        true
73    }
74
75    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::Result<()> {
76        while let Some(tag) = is.read_raw_tag_or_eof()? {
77            match tag {
78                10 => {
79                    self.file.push(is.read_message()?);
80                },
81                tag => {
82                    crate::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
83                },
84            };
85        }
86        ::std::result::Result::Ok(())
87    }
88
89    // Compute sizes of nested messages
90    #[allow(unused_variables)]
91    fn compute_size(&self) -> u64 {
92        let mut my_size = 0;
93        for value in &self.file {
94            let len = value.compute_size();
95            my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len;
96        };
97        my_size += crate::rt::unknown_fields_size(self.special_fields.unknown_fields());
98        self.special_fields.cached_size().set(my_size as u32);
99        my_size
100    }
101
102    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::Result<()> {
103        for v in &self.file {
104            crate::rt::write_message_field_with_cached_size(1, v, os)?;
105        };
106        os.write_unknown_fields(self.special_fields.unknown_fields())?;
107        ::std::result::Result::Ok(())
108    }
109
110    fn special_fields(&self) -> &crate::SpecialFields {
111        &self.special_fields
112    }
113
114    fn mut_special_fields(&mut self) -> &mut crate::SpecialFields {
115        &mut self.special_fields
116    }
117
118    fn new() -> FileDescriptorSet {
119        FileDescriptorSet::new()
120    }
121
122    fn clear(&mut self) {
123        self.file.clear();
124        self.special_fields.clear();
125    }
126
127    fn default_instance() -> &'static FileDescriptorSet {
128        static instance: FileDescriptorSet = FileDescriptorSet {
129            file: ::std::vec::Vec::new(),
130            special_fields: crate::SpecialFields::new(),
131        };
132        &instance
133    }
134}
135
136impl crate::MessageFull for FileDescriptorSet {
137    fn descriptor() -> crate::reflect::MessageDescriptor {
138        static descriptor: crate::rt::Lazy<crate::reflect::MessageDescriptor> = crate::rt::Lazy::new();
139        descriptor.get(|| file_descriptor().message_by_package_relative_name("FileDescriptorSet").unwrap()).clone()
140    }
141}
142
143impl ::std::fmt::Display for FileDescriptorSet {
144    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
145        crate::text_format::fmt(self, f)
146    }
147}
148
149impl crate::reflect::ProtobufValue for FileDescriptorSet {
150    type RuntimeType = crate::reflect::rt::RuntimeTypeMessage<Self>;
151}
152
153///  Describes a complete .proto file.
154// @@protoc_insertion_point(message:google.protobuf.FileDescriptorProto)
155#[derive(PartialEq,Clone,Default,Debug)]
156pub struct FileDescriptorProto {
157    // message fields
158    // @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.name)
159    pub name: ::std::option::Option<::std::string::String>,
160    // @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.package)
161    pub package: ::std::option::Option<::std::string::String>,
162    ///  Names of files imported by this file.
163    // @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.dependency)
164    pub dependency: ::std::vec::Vec<::std::string::String>,
165    ///  Indexes of the public imported files in the dependency list above.
166    // @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.public_dependency)
167    pub public_dependency: ::std::vec::Vec<i32>,
168    ///  Indexes of the weak imported files in the dependency list.
169    ///  For Google-internal migration only. Do not use.
170    // @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.weak_dependency)
171    pub weak_dependency: ::std::vec::Vec<i32>,
172    ///  All top-level definitions in this file.
173    // @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.message_type)
174    pub message_type: ::std::vec::Vec<DescriptorProto>,
175    // @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.enum_type)
176    pub enum_type: ::std::vec::Vec<EnumDescriptorProto>,
177    // @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.service)
178    pub service: ::std::vec::Vec<ServiceDescriptorProto>,
179    // @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.extension)
180    pub extension: ::std::vec::Vec<FieldDescriptorProto>,
181    // @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.options)
182    pub options: crate::MessageField<FileOptions>,
183    ///  This field contains optional information about the original source code.
184    ///  You may safely remove this entire field without harming runtime
185    ///  functionality of the descriptors -- the information is needed only by
186    ///  development tools.
187    // @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.source_code_info)
188    pub source_code_info: crate::MessageField<SourceCodeInfo>,
189    ///  The syntax of the proto file.
190    ///  The supported values are "proto2" and "proto3".
191    // @@protoc_insertion_point(field:google.protobuf.FileDescriptorProto.syntax)
192    pub syntax: ::std::option::Option<::std::string::String>,
193    // special fields
194    // @@protoc_insertion_point(special_field:google.protobuf.FileDescriptorProto.special_fields)
195    pub special_fields: crate::SpecialFields,
196}
197
198impl<'a> ::std::default::Default for &'a FileDescriptorProto {
199    fn default() -> &'a FileDescriptorProto {
200        <FileDescriptorProto as crate::Message>::default_instance()
201    }
202}
203
204impl FileDescriptorProto {
205    pub fn new() -> FileDescriptorProto {
206        ::std::default::Default::default()
207    }
208
209    // optional string name = 1;
210
211    pub fn name(&self) -> &str {
212        match self.name.as_ref() {
213            Some(v) => v,
214            None => "",
215        }
216    }
217
218    pub fn clear_name(&mut self) {
219        self.name = ::std::option::Option::None;
220    }
221
222    pub fn has_name(&self) -> bool {
223        self.name.is_some()
224    }
225
226    // Param is passed by value, moved
227    pub fn set_name(&mut self, v: ::std::string::String) {
228        self.name = ::std::option::Option::Some(v);
229    }
230
231    // Mutable pointer to the field.
232    // If field is not initialized, it is initialized with default value first.
233    pub fn mut_name(&mut self) -> &mut ::std::string::String {
234        if self.name.is_none() {
235            self.name = ::std::option::Option::Some(::std::string::String::new());
236        }
237        self.name.as_mut().unwrap()
238    }
239
240    // Take field
241    pub fn take_name(&mut self) -> ::std::string::String {
242        self.name.take().unwrap_or_else(|| ::std::string::String::new())
243    }
244
245    // optional string package = 2;
246
247    pub fn package(&self) -> &str {
248        match self.package.as_ref() {
249            Some(v) => v,
250            None => "",
251        }
252    }
253
254    pub fn clear_package(&mut self) {
255        self.package = ::std::option::Option::None;
256    }
257
258    pub fn has_package(&self) -> bool {
259        self.package.is_some()
260    }
261
262    // Param is passed by value, moved
263    pub fn set_package(&mut self, v: ::std::string::String) {
264        self.package = ::std::option::Option::Some(v);
265    }
266
267    // Mutable pointer to the field.
268    // If field is not initialized, it is initialized with default value first.
269    pub fn mut_package(&mut self) -> &mut ::std::string::String {
270        if self.package.is_none() {
271            self.package = ::std::option::Option::Some(::std::string::String::new());
272        }
273        self.package.as_mut().unwrap()
274    }
275
276    // Take field
277    pub fn take_package(&mut self) -> ::std::string::String {
278        self.package.take().unwrap_or_else(|| ::std::string::String::new())
279    }
280
281    // optional string syntax = 12;
282
283    pub fn syntax(&self) -> &str {
284        match self.syntax.as_ref() {
285            Some(v) => v,
286            None => "",
287        }
288    }
289
290    pub fn clear_syntax(&mut self) {
291        self.syntax = ::std::option::Option::None;
292    }
293
294    pub fn has_syntax(&self) -> bool {
295        self.syntax.is_some()
296    }
297
298    // Param is passed by value, moved
299    pub fn set_syntax(&mut self, v: ::std::string::String) {
300        self.syntax = ::std::option::Option::Some(v);
301    }
302
303    // Mutable pointer to the field.
304    // If field is not initialized, it is initialized with default value first.
305    pub fn mut_syntax(&mut self) -> &mut ::std::string::String {
306        if self.syntax.is_none() {
307            self.syntax = ::std::option::Option::Some(::std::string::String::new());
308        }
309        self.syntax.as_mut().unwrap()
310    }
311
312    // Take field
313    pub fn take_syntax(&mut self) -> ::std::string::String {
314        self.syntax.take().unwrap_or_else(|| ::std::string::String::new())
315    }
316
317    fn generated_message_descriptor_data() -> crate::reflect::GeneratedMessageDescriptorData {
318        let mut fields = ::std::vec::Vec::with_capacity(12);
319        let mut oneofs = ::std::vec::Vec::with_capacity(0);
320        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
321            "name",
322            |m: &FileDescriptorProto| { &m.name },
323            |m: &mut FileDescriptorProto| { &mut m.name },
324        ));
325        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
326            "package",
327            |m: &FileDescriptorProto| { &m.package },
328            |m: &mut FileDescriptorProto| { &mut m.package },
329        ));
330        fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
331            "dependency",
332            |m: &FileDescriptorProto| { &m.dependency },
333            |m: &mut FileDescriptorProto| { &mut m.dependency },
334        ));
335        fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
336            "public_dependency",
337            |m: &FileDescriptorProto| { &m.public_dependency },
338            |m: &mut FileDescriptorProto| { &mut m.public_dependency },
339        ));
340        fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
341            "weak_dependency",
342            |m: &FileDescriptorProto| { &m.weak_dependency },
343            |m: &mut FileDescriptorProto| { &mut m.weak_dependency },
344        ));
345        fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
346            "message_type",
347            |m: &FileDescriptorProto| { &m.message_type },
348            |m: &mut FileDescriptorProto| { &mut m.message_type },
349        ));
350        fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
351            "enum_type",
352            |m: &FileDescriptorProto| { &m.enum_type },
353            |m: &mut FileDescriptorProto| { &mut m.enum_type },
354        ));
355        fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
356            "service",
357            |m: &FileDescriptorProto| { &m.service },
358            |m: &mut FileDescriptorProto| { &mut m.service },
359        ));
360        fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
361            "extension",
362            |m: &FileDescriptorProto| { &m.extension },
363            |m: &mut FileDescriptorProto| { &mut m.extension },
364        ));
365        fields.push(crate::reflect::rt::v2::make_message_field_accessor::<_, FileOptions>(
366            "options",
367            |m: &FileDescriptorProto| { &m.options },
368            |m: &mut FileDescriptorProto| { &mut m.options },
369        ));
370        fields.push(crate::reflect::rt::v2::make_message_field_accessor::<_, SourceCodeInfo>(
371            "source_code_info",
372            |m: &FileDescriptorProto| { &m.source_code_info },
373            |m: &mut FileDescriptorProto| { &mut m.source_code_info },
374        ));
375        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
376            "syntax",
377            |m: &FileDescriptorProto| { &m.syntax },
378            |m: &mut FileDescriptorProto| { &mut m.syntax },
379        ));
380        crate::reflect::GeneratedMessageDescriptorData::new_2::<FileDescriptorProto>(
381            "FileDescriptorProto",
382            fields,
383            oneofs,
384        )
385    }
386}
387
388impl crate::Message for FileDescriptorProto {
389    const NAME: &'static str = "FileDescriptorProto";
390
391    fn is_initialized(&self) -> bool {
392        for v in &self.message_type {
393            if !v.is_initialized() {
394                return false;
395            }
396        };
397        for v in &self.enum_type {
398            if !v.is_initialized() {
399                return false;
400            }
401        };
402        for v in &self.service {
403            if !v.is_initialized() {
404                return false;
405            }
406        };
407        for v in &self.extension {
408            if !v.is_initialized() {
409                return false;
410            }
411        };
412        for v in &self.options {
413            if !v.is_initialized() {
414                return false;
415            }
416        };
417        for v in &self.source_code_info {
418            if !v.is_initialized() {
419                return false;
420            }
421        };
422        true
423    }
424
425    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::Result<()> {
426        while let Some(tag) = is.read_raw_tag_or_eof()? {
427            match tag {
428                10 => {
429                    self.name = ::std::option::Option::Some(is.read_string()?);
430                },
431                18 => {
432                    self.package = ::std::option::Option::Some(is.read_string()?);
433                },
434                26 => {
435                    self.dependency.push(is.read_string()?);
436                },
437                82 => {
438                    is.read_repeated_packed_int32_into(&mut self.public_dependency)?;
439                },
440                80 => {
441                    self.public_dependency.push(is.read_int32()?);
442                },
443                90 => {
444                    is.read_repeated_packed_int32_into(&mut self.weak_dependency)?;
445                },
446                88 => {
447                    self.weak_dependency.push(is.read_int32()?);
448                },
449                34 => {
450                    self.message_type.push(is.read_message()?);
451                },
452                42 => {
453                    self.enum_type.push(is.read_message()?);
454                },
455                50 => {
456                    self.service.push(is.read_message()?);
457                },
458                58 => {
459                    self.extension.push(is.read_message()?);
460                },
461                66 => {
462                    crate::rt::read_singular_message_into_field(is, &mut self.options)?;
463                },
464                74 => {
465                    crate::rt::read_singular_message_into_field(is, &mut self.source_code_info)?;
466                },
467                98 => {
468                    self.syntax = ::std::option::Option::Some(is.read_string()?);
469                },
470                tag => {
471                    crate::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
472                },
473            };
474        }
475        ::std::result::Result::Ok(())
476    }
477
478    // Compute sizes of nested messages
479    #[allow(unused_variables)]
480    fn compute_size(&self) -> u64 {
481        let mut my_size = 0;
482        if let Some(v) = self.name.as_ref() {
483            my_size += crate::rt::string_size(1, &v);
484        }
485        if let Some(v) = self.package.as_ref() {
486            my_size += crate::rt::string_size(2, &v);
487        }
488        for value in &self.dependency {
489            my_size += crate::rt::string_size(3, &value);
490        };
491        for value in &self.public_dependency {
492            my_size += crate::rt::int32_size(10, *value);
493        };
494        for value in &self.weak_dependency {
495            my_size += crate::rt::int32_size(11, *value);
496        };
497        for value in &self.message_type {
498            let len = value.compute_size();
499            my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len;
500        };
501        for value in &self.enum_type {
502            let len = value.compute_size();
503            my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len;
504        };
505        for value in &self.service {
506            let len = value.compute_size();
507            my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len;
508        };
509        for value in &self.extension {
510            let len = value.compute_size();
511            my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len;
512        };
513        if let Some(v) = self.options.as_ref() {
514            let len = v.compute_size();
515            my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len;
516        }
517        if let Some(v) = self.source_code_info.as_ref() {
518            let len = v.compute_size();
519            my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len;
520        }
521        if let Some(v) = self.syntax.as_ref() {
522            my_size += crate::rt::string_size(12, &v);
523        }
524        my_size += crate::rt::unknown_fields_size(self.special_fields.unknown_fields());
525        self.special_fields.cached_size().set(my_size as u32);
526        my_size
527    }
528
529    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::Result<()> {
530        if let Some(v) = self.name.as_ref() {
531            os.write_string(1, v)?;
532        }
533        if let Some(v) = self.package.as_ref() {
534            os.write_string(2, v)?;
535        }
536        for v in &self.dependency {
537            os.write_string(3, &v)?;
538        };
539        for v in &self.public_dependency {
540            os.write_int32(10, *v)?;
541        };
542        for v in &self.weak_dependency {
543            os.write_int32(11, *v)?;
544        };
545        for v in &self.message_type {
546            crate::rt::write_message_field_with_cached_size(4, v, os)?;
547        };
548        for v in &self.enum_type {
549            crate::rt::write_message_field_with_cached_size(5, v, os)?;
550        };
551        for v in &self.service {
552            crate::rt::write_message_field_with_cached_size(6, v, os)?;
553        };
554        for v in &self.extension {
555            crate::rt::write_message_field_with_cached_size(7, v, os)?;
556        };
557        if let Some(v) = self.options.as_ref() {
558            crate::rt::write_message_field_with_cached_size(8, v, os)?;
559        }
560        if let Some(v) = self.source_code_info.as_ref() {
561            crate::rt::write_message_field_with_cached_size(9, v, os)?;
562        }
563        if let Some(v) = self.syntax.as_ref() {
564            os.write_string(12, v)?;
565        }
566        os.write_unknown_fields(self.special_fields.unknown_fields())?;
567        ::std::result::Result::Ok(())
568    }
569
570    fn special_fields(&self) -> &crate::SpecialFields {
571        &self.special_fields
572    }
573
574    fn mut_special_fields(&mut self) -> &mut crate::SpecialFields {
575        &mut self.special_fields
576    }
577
578    fn new() -> FileDescriptorProto {
579        FileDescriptorProto::new()
580    }
581
582    fn clear(&mut self) {
583        self.name = ::std::option::Option::None;
584        self.package = ::std::option::Option::None;
585        self.dependency.clear();
586        self.public_dependency.clear();
587        self.weak_dependency.clear();
588        self.message_type.clear();
589        self.enum_type.clear();
590        self.service.clear();
591        self.extension.clear();
592        self.options.clear();
593        self.source_code_info.clear();
594        self.syntax = ::std::option::Option::None;
595        self.special_fields.clear();
596    }
597
598    fn default_instance() -> &'static FileDescriptorProto {
599        static instance: FileDescriptorProto = FileDescriptorProto {
600            name: ::std::option::Option::None,
601            package: ::std::option::Option::None,
602            dependency: ::std::vec::Vec::new(),
603            public_dependency: ::std::vec::Vec::new(),
604            weak_dependency: ::std::vec::Vec::new(),
605            message_type: ::std::vec::Vec::new(),
606            enum_type: ::std::vec::Vec::new(),
607            service: ::std::vec::Vec::new(),
608            extension: ::std::vec::Vec::new(),
609            options: crate::MessageField::none(),
610            source_code_info: crate::MessageField::none(),
611            syntax: ::std::option::Option::None,
612            special_fields: crate::SpecialFields::new(),
613        };
614        &instance
615    }
616}
617
618impl crate::MessageFull for FileDescriptorProto {
619    fn descriptor() -> crate::reflect::MessageDescriptor {
620        static descriptor: crate::rt::Lazy<crate::reflect::MessageDescriptor> = crate::rt::Lazy::new();
621        descriptor.get(|| file_descriptor().message_by_package_relative_name("FileDescriptorProto").unwrap()).clone()
622    }
623}
624
625impl ::std::fmt::Display for FileDescriptorProto {
626    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
627        crate::text_format::fmt(self, f)
628    }
629}
630
631impl crate::reflect::ProtobufValue for FileDescriptorProto {
632    type RuntimeType = crate::reflect::rt::RuntimeTypeMessage<Self>;
633}
634
635///  Describes a message type.
636// @@protoc_insertion_point(message:google.protobuf.DescriptorProto)
637#[derive(PartialEq,Clone,Default,Debug)]
638pub struct DescriptorProto {
639    // message fields
640    // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.name)
641    pub name: ::std::option::Option<::std::string::String>,
642    // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.field)
643    pub field: ::std::vec::Vec<FieldDescriptorProto>,
644    // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.extension)
645    pub extension: ::std::vec::Vec<FieldDescriptorProto>,
646    // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.nested_type)
647    pub nested_type: ::std::vec::Vec<DescriptorProto>,
648    // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.enum_type)
649    pub enum_type: ::std::vec::Vec<EnumDescriptorProto>,
650    // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.extension_range)
651    pub extension_range: ::std::vec::Vec<descriptor_proto::ExtensionRange>,
652    // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.oneof_decl)
653    pub oneof_decl: ::std::vec::Vec<OneofDescriptorProto>,
654    // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.options)
655    pub options: crate::MessageField<MessageOptions>,
656    // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.reserved_range)
657    pub reserved_range: ::std::vec::Vec<descriptor_proto::ReservedRange>,
658    ///  Reserved field names, which may not be used by fields in the same message.
659    ///  A given name may only be reserved once.
660    // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.reserved_name)
661    pub reserved_name: ::std::vec::Vec<::std::string::String>,
662    // special fields
663    // @@protoc_insertion_point(special_field:google.protobuf.DescriptorProto.special_fields)
664    pub special_fields: crate::SpecialFields,
665}
666
667impl<'a> ::std::default::Default for &'a DescriptorProto {
668    fn default() -> &'a DescriptorProto {
669        <DescriptorProto as crate::Message>::default_instance()
670    }
671}
672
673impl DescriptorProto {
674    pub fn new() -> DescriptorProto {
675        ::std::default::Default::default()
676    }
677
678    // optional string name = 1;
679
680    pub fn name(&self) -> &str {
681        match self.name.as_ref() {
682            Some(v) => v,
683            None => "",
684        }
685    }
686
687    pub fn clear_name(&mut self) {
688        self.name = ::std::option::Option::None;
689    }
690
691    pub fn has_name(&self) -> bool {
692        self.name.is_some()
693    }
694
695    // Param is passed by value, moved
696    pub fn set_name(&mut self, v: ::std::string::String) {
697        self.name = ::std::option::Option::Some(v);
698    }
699
700    // Mutable pointer to the field.
701    // If field is not initialized, it is initialized with default value first.
702    pub fn mut_name(&mut self) -> &mut ::std::string::String {
703        if self.name.is_none() {
704            self.name = ::std::option::Option::Some(::std::string::String::new());
705        }
706        self.name.as_mut().unwrap()
707    }
708
709    // Take field
710    pub fn take_name(&mut self) -> ::std::string::String {
711        self.name.take().unwrap_or_else(|| ::std::string::String::new())
712    }
713
714    fn generated_message_descriptor_data() -> crate::reflect::GeneratedMessageDescriptorData {
715        let mut fields = ::std::vec::Vec::with_capacity(10);
716        let mut oneofs = ::std::vec::Vec::with_capacity(0);
717        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
718            "name",
719            |m: &DescriptorProto| { &m.name },
720            |m: &mut DescriptorProto| { &mut m.name },
721        ));
722        fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
723            "field",
724            |m: &DescriptorProto| { &m.field },
725            |m: &mut DescriptorProto| { &mut m.field },
726        ));
727        fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
728            "extension",
729            |m: &DescriptorProto| { &m.extension },
730            |m: &mut DescriptorProto| { &mut m.extension },
731        ));
732        fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
733            "nested_type",
734            |m: &DescriptorProto| { &m.nested_type },
735            |m: &mut DescriptorProto| { &mut m.nested_type },
736        ));
737        fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
738            "enum_type",
739            |m: &DescriptorProto| { &m.enum_type },
740            |m: &mut DescriptorProto| { &mut m.enum_type },
741        ));
742        fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
743            "extension_range",
744            |m: &DescriptorProto| { &m.extension_range },
745            |m: &mut DescriptorProto| { &mut m.extension_range },
746        ));
747        fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
748            "oneof_decl",
749            |m: &DescriptorProto| { &m.oneof_decl },
750            |m: &mut DescriptorProto| { &mut m.oneof_decl },
751        ));
752        fields.push(crate::reflect::rt::v2::make_message_field_accessor::<_, MessageOptions>(
753            "options",
754            |m: &DescriptorProto| { &m.options },
755            |m: &mut DescriptorProto| { &mut m.options },
756        ));
757        fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
758            "reserved_range",
759            |m: &DescriptorProto| { &m.reserved_range },
760            |m: &mut DescriptorProto| { &mut m.reserved_range },
761        ));
762        fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
763            "reserved_name",
764            |m: &DescriptorProto| { &m.reserved_name },
765            |m: &mut DescriptorProto| { &mut m.reserved_name },
766        ));
767        crate::reflect::GeneratedMessageDescriptorData::new_2::<DescriptorProto>(
768            "DescriptorProto",
769            fields,
770            oneofs,
771        )
772    }
773}
774
775impl crate::Message for DescriptorProto {
776    const NAME: &'static str = "DescriptorProto";
777
778    fn is_initialized(&self) -> bool {
779        for v in &self.field {
780            if !v.is_initialized() {
781                return false;
782            }
783        };
784        for v in &self.extension {
785            if !v.is_initialized() {
786                return false;
787            }
788        };
789        for v in &self.nested_type {
790            if !v.is_initialized() {
791                return false;
792            }
793        };
794        for v in &self.enum_type {
795            if !v.is_initialized() {
796                return false;
797            }
798        };
799        for v in &self.extension_range {
800            if !v.is_initialized() {
801                return false;
802            }
803        };
804        for v in &self.oneof_decl {
805            if !v.is_initialized() {
806                return false;
807            }
808        };
809        for v in &self.options {
810            if !v.is_initialized() {
811                return false;
812            }
813        };
814        for v in &self.reserved_range {
815            if !v.is_initialized() {
816                return false;
817            }
818        };
819        true
820    }
821
822    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::Result<()> {
823        while let Some(tag) = is.read_raw_tag_or_eof()? {
824            match tag {
825                10 => {
826                    self.name = ::std::option::Option::Some(is.read_string()?);
827                },
828                18 => {
829                    self.field.push(is.read_message()?);
830                },
831                50 => {
832                    self.extension.push(is.read_message()?);
833                },
834                26 => {
835                    self.nested_type.push(is.read_message()?);
836                },
837                34 => {
838                    self.enum_type.push(is.read_message()?);
839                },
840                42 => {
841                    self.extension_range.push(is.read_message()?);
842                },
843                66 => {
844                    self.oneof_decl.push(is.read_message()?);
845                },
846                58 => {
847                    crate::rt::read_singular_message_into_field(is, &mut self.options)?;
848                },
849                74 => {
850                    self.reserved_range.push(is.read_message()?);
851                },
852                82 => {
853                    self.reserved_name.push(is.read_string()?);
854                },
855                tag => {
856                    crate::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
857                },
858            };
859        }
860        ::std::result::Result::Ok(())
861    }
862
863    // Compute sizes of nested messages
864    #[allow(unused_variables)]
865    fn compute_size(&self) -> u64 {
866        let mut my_size = 0;
867        if let Some(v) = self.name.as_ref() {
868            my_size += crate::rt::string_size(1, &v);
869        }
870        for value in &self.field {
871            let len = value.compute_size();
872            my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len;
873        };
874        for value in &self.extension {
875            let len = value.compute_size();
876            my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len;
877        };
878        for value in &self.nested_type {
879            let len = value.compute_size();
880            my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len;
881        };
882        for value in &self.enum_type {
883            let len = value.compute_size();
884            my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len;
885        };
886        for value in &self.extension_range {
887            let len = value.compute_size();
888            my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len;
889        };
890        for value in &self.oneof_decl {
891            let len = value.compute_size();
892            my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len;
893        };
894        if let Some(v) = self.options.as_ref() {
895            let len = v.compute_size();
896            my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len;
897        }
898        for value in &self.reserved_range {
899            let len = value.compute_size();
900            my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len;
901        };
902        for value in &self.reserved_name {
903            my_size += crate::rt::string_size(10, &value);
904        };
905        my_size += crate::rt::unknown_fields_size(self.special_fields.unknown_fields());
906        self.special_fields.cached_size().set(my_size as u32);
907        my_size
908    }
909
910    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::Result<()> {
911        if let Some(v) = self.name.as_ref() {
912            os.write_string(1, v)?;
913        }
914        for v in &self.field {
915            crate::rt::write_message_field_with_cached_size(2, v, os)?;
916        };
917        for v in &self.extension {
918            crate::rt::write_message_field_with_cached_size(6, v, os)?;
919        };
920        for v in &self.nested_type {
921            crate::rt::write_message_field_with_cached_size(3, v, os)?;
922        };
923        for v in &self.enum_type {
924            crate::rt::write_message_field_with_cached_size(4, v, os)?;
925        };
926        for v in &self.extension_range {
927            crate::rt::write_message_field_with_cached_size(5, v, os)?;
928        };
929        for v in &self.oneof_decl {
930            crate::rt::write_message_field_with_cached_size(8, v, os)?;
931        };
932        if let Some(v) = self.options.as_ref() {
933            crate::rt::write_message_field_with_cached_size(7, v, os)?;
934        }
935        for v in &self.reserved_range {
936            crate::rt::write_message_field_with_cached_size(9, v, os)?;
937        };
938        for v in &self.reserved_name {
939            os.write_string(10, &v)?;
940        };
941        os.write_unknown_fields(self.special_fields.unknown_fields())?;
942        ::std::result::Result::Ok(())
943    }
944
945    fn special_fields(&self) -> &crate::SpecialFields {
946        &self.special_fields
947    }
948
949    fn mut_special_fields(&mut self) -> &mut crate::SpecialFields {
950        &mut self.special_fields
951    }
952
953    fn new() -> DescriptorProto {
954        DescriptorProto::new()
955    }
956
957    fn clear(&mut self) {
958        self.name = ::std::option::Option::None;
959        self.field.clear();
960        self.extension.clear();
961        self.nested_type.clear();
962        self.enum_type.clear();
963        self.extension_range.clear();
964        self.oneof_decl.clear();
965        self.options.clear();
966        self.reserved_range.clear();
967        self.reserved_name.clear();
968        self.special_fields.clear();
969    }
970
971    fn default_instance() -> &'static DescriptorProto {
972        static instance: DescriptorProto = DescriptorProto {
973            name: ::std::option::Option::None,
974            field: ::std::vec::Vec::new(),
975            extension: ::std::vec::Vec::new(),
976            nested_type: ::std::vec::Vec::new(),
977            enum_type: ::std::vec::Vec::new(),
978            extension_range: ::std::vec::Vec::new(),
979            oneof_decl: ::std::vec::Vec::new(),
980            options: crate::MessageField::none(),
981            reserved_range: ::std::vec::Vec::new(),
982            reserved_name: ::std::vec::Vec::new(),
983            special_fields: crate::SpecialFields::new(),
984        };
985        &instance
986    }
987}
988
989impl crate::MessageFull for DescriptorProto {
990    fn descriptor() -> crate::reflect::MessageDescriptor {
991        static descriptor: crate::rt::Lazy<crate::reflect::MessageDescriptor> = crate::rt::Lazy::new();
992        descriptor.get(|| file_descriptor().message_by_package_relative_name("DescriptorProto").unwrap()).clone()
993    }
994}
995
996impl ::std::fmt::Display for DescriptorProto {
997    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
998        crate::text_format::fmt(self, f)
999    }
1000}
1001
1002impl crate::reflect::ProtobufValue for DescriptorProto {
1003    type RuntimeType = crate::reflect::rt::RuntimeTypeMessage<Self>;
1004}
1005
1006/// Nested message and enums of message `DescriptorProto`
1007pub mod descriptor_proto {
1008    // @@protoc_insertion_point(message:google.protobuf.DescriptorProto.ExtensionRange)
1009    #[derive(PartialEq,Clone,Default,Debug)]
1010    pub struct ExtensionRange {
1011        // message fields
1012        // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.ExtensionRange.start)
1013        pub start: ::std::option::Option<i32>,
1014        // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.ExtensionRange.end)
1015        pub end: ::std::option::Option<i32>,
1016        // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.ExtensionRange.options)
1017        pub options: crate::MessageField<super::ExtensionRangeOptions>,
1018        // special fields
1019        // @@protoc_insertion_point(special_field:google.protobuf.DescriptorProto.ExtensionRange.special_fields)
1020        pub special_fields: crate::SpecialFields,
1021    }
1022
1023    impl<'a> ::std::default::Default for &'a ExtensionRange {
1024        fn default() -> &'a ExtensionRange {
1025            <ExtensionRange as crate::Message>::default_instance()
1026        }
1027    }
1028
1029    impl ExtensionRange {
1030        pub fn new() -> ExtensionRange {
1031            ::std::default::Default::default()
1032        }
1033
1034        // optional int32 start = 1;
1035
1036        pub fn start(&self) -> i32 {
1037            self.start.unwrap_or(0)
1038        }
1039
1040        pub fn clear_start(&mut self) {
1041            self.start = ::std::option::Option::None;
1042        }
1043
1044        pub fn has_start(&self) -> bool {
1045            self.start.is_some()
1046        }
1047
1048        // Param is passed by value, moved
1049        pub fn set_start(&mut self, v: i32) {
1050            self.start = ::std::option::Option::Some(v);
1051        }
1052
1053        // optional int32 end = 2;
1054
1055        pub fn end(&self) -> i32 {
1056            self.end.unwrap_or(0)
1057        }
1058
1059        pub fn clear_end(&mut self) {
1060            self.end = ::std::option::Option::None;
1061        }
1062
1063        pub fn has_end(&self) -> bool {
1064            self.end.is_some()
1065        }
1066
1067        // Param is passed by value, moved
1068        pub fn set_end(&mut self, v: i32) {
1069            self.end = ::std::option::Option::Some(v);
1070        }
1071
1072        pub(in super) fn generated_message_descriptor_data() -> crate::reflect::GeneratedMessageDescriptorData {
1073            let mut fields = ::std::vec::Vec::with_capacity(3);
1074            let mut oneofs = ::std::vec::Vec::with_capacity(0);
1075            fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
1076                "start",
1077                |m: &ExtensionRange| { &m.start },
1078                |m: &mut ExtensionRange| { &mut m.start },
1079            ));
1080            fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
1081                "end",
1082                |m: &ExtensionRange| { &m.end },
1083                |m: &mut ExtensionRange| { &mut m.end },
1084            ));
1085            fields.push(crate::reflect::rt::v2::make_message_field_accessor::<_, super::ExtensionRangeOptions>(
1086                "options",
1087                |m: &ExtensionRange| { &m.options },
1088                |m: &mut ExtensionRange| { &mut m.options },
1089            ));
1090            crate::reflect::GeneratedMessageDescriptorData::new_2::<ExtensionRange>(
1091                "DescriptorProto.ExtensionRange",
1092                fields,
1093                oneofs,
1094            )
1095        }
1096    }
1097
1098    impl crate::Message for ExtensionRange {
1099        const NAME: &'static str = "ExtensionRange";
1100
1101        fn is_initialized(&self) -> bool {
1102            for v in &self.options {
1103                if !v.is_initialized() {
1104                    return false;
1105                }
1106            };
1107            true
1108        }
1109
1110        fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::Result<()> {
1111            while let Some(tag) = is.read_raw_tag_or_eof()? {
1112                match tag {
1113                    8 => {
1114                        self.start = ::std::option::Option::Some(is.read_int32()?);
1115                    },
1116                    16 => {
1117                        self.end = ::std::option::Option::Some(is.read_int32()?);
1118                    },
1119                    26 => {
1120                        crate::rt::read_singular_message_into_field(is, &mut self.options)?;
1121                    },
1122                    tag => {
1123                        crate::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1124                    },
1125                };
1126            }
1127            ::std::result::Result::Ok(())
1128        }
1129
1130        // Compute sizes of nested messages
1131        #[allow(unused_variables)]
1132        fn compute_size(&self) -> u64 {
1133            let mut my_size = 0;
1134            if let Some(v) = self.start {
1135                my_size += crate::rt::int32_size(1, v);
1136            }
1137            if let Some(v) = self.end {
1138                my_size += crate::rt::int32_size(2, v);
1139            }
1140            if let Some(v) = self.options.as_ref() {
1141                let len = v.compute_size();
1142                my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len;
1143            }
1144            my_size += crate::rt::unknown_fields_size(self.special_fields.unknown_fields());
1145            self.special_fields.cached_size().set(my_size as u32);
1146            my_size
1147        }
1148
1149        fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::Result<()> {
1150            if let Some(v) = self.start {
1151                os.write_int32(1, v)?;
1152            }
1153            if let Some(v) = self.end {
1154                os.write_int32(2, v)?;
1155            }
1156            if let Some(v) = self.options.as_ref() {
1157                crate::rt::write_message_field_with_cached_size(3, v, os)?;
1158            }
1159            os.write_unknown_fields(self.special_fields.unknown_fields())?;
1160            ::std::result::Result::Ok(())
1161        }
1162
1163        fn special_fields(&self) -> &crate::SpecialFields {
1164            &self.special_fields
1165        }
1166
1167        fn mut_special_fields(&mut self) -> &mut crate::SpecialFields {
1168            &mut self.special_fields
1169        }
1170
1171        fn new() -> ExtensionRange {
1172            ExtensionRange::new()
1173        }
1174
1175        fn clear(&mut self) {
1176            self.start = ::std::option::Option::None;
1177            self.end = ::std::option::Option::None;
1178            self.options.clear();
1179            self.special_fields.clear();
1180        }
1181
1182        fn default_instance() -> &'static ExtensionRange {
1183            static instance: ExtensionRange = ExtensionRange {
1184                start: ::std::option::Option::None,
1185                end: ::std::option::Option::None,
1186                options: crate::MessageField::none(),
1187                special_fields: crate::SpecialFields::new(),
1188            };
1189            &instance
1190        }
1191    }
1192
1193    impl crate::MessageFull for ExtensionRange {
1194        fn descriptor() -> crate::reflect::MessageDescriptor {
1195            static descriptor: crate::rt::Lazy<crate::reflect::MessageDescriptor> = crate::rt::Lazy::new();
1196            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("DescriptorProto.ExtensionRange").unwrap()).clone()
1197        }
1198    }
1199
1200    impl ::std::fmt::Display for ExtensionRange {
1201        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1202            crate::text_format::fmt(self, f)
1203        }
1204    }
1205
1206    impl crate::reflect::ProtobufValue for ExtensionRange {
1207        type RuntimeType = crate::reflect::rt::RuntimeTypeMessage<Self>;
1208    }
1209
1210    ///  Range of reserved tag numbers. Reserved tag numbers may not be used by
1211    ///  fields or extension ranges in the same message. Reserved ranges may
1212    ///  not overlap.
1213    // @@protoc_insertion_point(message:google.protobuf.DescriptorProto.ReservedRange)
1214    #[derive(PartialEq,Clone,Default,Debug)]
1215    pub struct ReservedRange {
1216        // message fields
1217        // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.ReservedRange.start)
1218        pub start: ::std::option::Option<i32>,
1219        // @@protoc_insertion_point(field:google.protobuf.DescriptorProto.ReservedRange.end)
1220        pub end: ::std::option::Option<i32>,
1221        // special fields
1222        // @@protoc_insertion_point(special_field:google.protobuf.DescriptorProto.ReservedRange.special_fields)
1223        pub special_fields: crate::SpecialFields,
1224    }
1225
1226    impl<'a> ::std::default::Default for &'a ReservedRange {
1227        fn default() -> &'a ReservedRange {
1228            <ReservedRange as crate::Message>::default_instance()
1229        }
1230    }
1231
1232    impl ReservedRange {
1233        pub fn new() -> ReservedRange {
1234            ::std::default::Default::default()
1235        }
1236
1237        // optional int32 start = 1;
1238
1239        pub fn start(&self) -> i32 {
1240            self.start.unwrap_or(0)
1241        }
1242
1243        pub fn clear_start(&mut self) {
1244            self.start = ::std::option::Option::None;
1245        }
1246
1247        pub fn has_start(&self) -> bool {
1248            self.start.is_some()
1249        }
1250
1251        // Param is passed by value, moved
1252        pub fn set_start(&mut self, v: i32) {
1253            self.start = ::std::option::Option::Some(v);
1254        }
1255
1256        // optional int32 end = 2;
1257
1258        pub fn end(&self) -> i32 {
1259            self.end.unwrap_or(0)
1260        }
1261
1262        pub fn clear_end(&mut self) {
1263            self.end = ::std::option::Option::None;
1264        }
1265
1266        pub fn has_end(&self) -> bool {
1267            self.end.is_some()
1268        }
1269
1270        // Param is passed by value, moved
1271        pub fn set_end(&mut self, v: i32) {
1272            self.end = ::std::option::Option::Some(v);
1273        }
1274
1275        pub(in super) fn generated_message_descriptor_data() -> crate::reflect::GeneratedMessageDescriptorData {
1276            let mut fields = ::std::vec::Vec::with_capacity(2);
1277            let mut oneofs = ::std::vec::Vec::with_capacity(0);
1278            fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
1279                "start",
1280                |m: &ReservedRange| { &m.start },
1281                |m: &mut ReservedRange| { &mut m.start },
1282            ));
1283            fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
1284                "end",
1285                |m: &ReservedRange| { &m.end },
1286                |m: &mut ReservedRange| { &mut m.end },
1287            ));
1288            crate::reflect::GeneratedMessageDescriptorData::new_2::<ReservedRange>(
1289                "DescriptorProto.ReservedRange",
1290                fields,
1291                oneofs,
1292            )
1293        }
1294    }
1295
1296    impl crate::Message for ReservedRange {
1297        const NAME: &'static str = "ReservedRange";
1298
1299        fn is_initialized(&self) -> bool {
1300            true
1301        }
1302
1303        fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::Result<()> {
1304            while let Some(tag) = is.read_raw_tag_or_eof()? {
1305                match tag {
1306                    8 => {
1307                        self.start = ::std::option::Option::Some(is.read_int32()?);
1308                    },
1309                    16 => {
1310                        self.end = ::std::option::Option::Some(is.read_int32()?);
1311                    },
1312                    tag => {
1313                        crate::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1314                    },
1315                };
1316            }
1317            ::std::result::Result::Ok(())
1318        }
1319
1320        // Compute sizes of nested messages
1321        #[allow(unused_variables)]
1322        fn compute_size(&self) -> u64 {
1323            let mut my_size = 0;
1324            if let Some(v) = self.start {
1325                my_size += crate::rt::int32_size(1, v);
1326            }
1327            if let Some(v) = self.end {
1328                my_size += crate::rt::int32_size(2, v);
1329            }
1330            my_size += crate::rt::unknown_fields_size(self.special_fields.unknown_fields());
1331            self.special_fields.cached_size().set(my_size as u32);
1332            my_size
1333        }
1334
1335        fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::Result<()> {
1336            if let Some(v) = self.start {
1337                os.write_int32(1, v)?;
1338            }
1339            if let Some(v) = self.end {
1340                os.write_int32(2, v)?;
1341            }
1342            os.write_unknown_fields(self.special_fields.unknown_fields())?;
1343            ::std::result::Result::Ok(())
1344        }
1345
1346        fn special_fields(&self) -> &crate::SpecialFields {
1347            &self.special_fields
1348        }
1349
1350        fn mut_special_fields(&mut self) -> &mut crate::SpecialFields {
1351            &mut self.special_fields
1352        }
1353
1354        fn new() -> ReservedRange {
1355            ReservedRange::new()
1356        }
1357
1358        fn clear(&mut self) {
1359            self.start = ::std::option::Option::None;
1360            self.end = ::std::option::Option::None;
1361            self.special_fields.clear();
1362        }
1363
1364        fn default_instance() -> &'static ReservedRange {
1365            static instance: ReservedRange = ReservedRange {
1366                start: ::std::option::Option::None,
1367                end: ::std::option::Option::None,
1368                special_fields: crate::SpecialFields::new(),
1369            };
1370            &instance
1371        }
1372    }
1373
1374    impl crate::MessageFull for ReservedRange {
1375        fn descriptor() -> crate::reflect::MessageDescriptor {
1376            static descriptor: crate::rt::Lazy<crate::reflect::MessageDescriptor> = crate::rt::Lazy::new();
1377            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("DescriptorProto.ReservedRange").unwrap()).clone()
1378        }
1379    }
1380
1381    impl ::std::fmt::Display for ReservedRange {
1382        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1383            crate::text_format::fmt(self, f)
1384        }
1385    }
1386
1387    impl crate::reflect::ProtobufValue for ReservedRange {
1388        type RuntimeType = crate::reflect::rt::RuntimeTypeMessage<Self>;
1389    }
1390}
1391
1392// @@protoc_insertion_point(message:google.protobuf.ExtensionRangeOptions)
1393#[derive(PartialEq,Clone,Default,Debug)]
1394pub struct ExtensionRangeOptions {
1395    // message fields
1396    ///  The parser stores options it doesn't recognize here. See above.
1397    // @@protoc_insertion_point(field:google.protobuf.ExtensionRangeOptions.uninterpreted_option)
1398    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
1399    // special fields
1400    // @@protoc_insertion_point(special_field:google.protobuf.ExtensionRangeOptions.special_fields)
1401    pub special_fields: crate::SpecialFields,
1402}
1403
1404impl<'a> ::std::default::Default for &'a ExtensionRangeOptions {
1405    fn default() -> &'a ExtensionRangeOptions {
1406        <ExtensionRangeOptions as crate::Message>::default_instance()
1407    }
1408}
1409
1410impl ExtensionRangeOptions {
1411    pub fn new() -> ExtensionRangeOptions {
1412        ::std::default::Default::default()
1413    }
1414
1415    fn generated_message_descriptor_data() -> crate::reflect::GeneratedMessageDescriptorData {
1416        let mut fields = ::std::vec::Vec::with_capacity(1);
1417        let mut oneofs = ::std::vec::Vec::with_capacity(0);
1418        fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
1419            "uninterpreted_option",
1420            |m: &ExtensionRangeOptions| { &m.uninterpreted_option },
1421            |m: &mut ExtensionRangeOptions| { &mut m.uninterpreted_option },
1422        ));
1423        crate::reflect::GeneratedMessageDescriptorData::new_2::<ExtensionRangeOptions>(
1424            "ExtensionRangeOptions",
1425            fields,
1426            oneofs,
1427        )
1428    }
1429}
1430
1431impl crate::Message for ExtensionRangeOptions {
1432    const NAME: &'static str = "ExtensionRangeOptions";
1433
1434    fn is_initialized(&self) -> bool {
1435        for v in &self.uninterpreted_option {
1436            if !v.is_initialized() {
1437                return false;
1438            }
1439        };
1440        true
1441    }
1442
1443    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::Result<()> {
1444        while let Some(tag) = is.read_raw_tag_or_eof()? {
1445            match tag {
1446                7994 => {
1447                    self.uninterpreted_option.push(is.read_message()?);
1448                },
1449                tag => {
1450                    crate::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1451                },
1452            };
1453        }
1454        ::std::result::Result::Ok(())
1455    }
1456
1457    // Compute sizes of nested messages
1458    #[allow(unused_variables)]
1459    fn compute_size(&self) -> u64 {
1460        let mut my_size = 0;
1461        for value in &self.uninterpreted_option {
1462            let len = value.compute_size();
1463            my_size += 2 + crate::rt::compute_raw_varint64_size(len) + len;
1464        };
1465        my_size += crate::rt::unknown_fields_size(self.special_fields.unknown_fields());
1466        self.special_fields.cached_size().set(my_size as u32);
1467        my_size
1468    }
1469
1470    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::Result<()> {
1471        for v in &self.uninterpreted_option {
1472            crate::rt::write_message_field_with_cached_size(999, v, os)?;
1473        };
1474        os.write_unknown_fields(self.special_fields.unknown_fields())?;
1475        ::std::result::Result::Ok(())
1476    }
1477
1478    fn special_fields(&self) -> &crate::SpecialFields {
1479        &self.special_fields
1480    }
1481
1482    fn mut_special_fields(&mut self) -> &mut crate::SpecialFields {
1483        &mut self.special_fields
1484    }
1485
1486    fn new() -> ExtensionRangeOptions {
1487        ExtensionRangeOptions::new()
1488    }
1489
1490    fn clear(&mut self) {
1491        self.uninterpreted_option.clear();
1492        self.special_fields.clear();
1493    }
1494
1495    fn default_instance() -> &'static ExtensionRangeOptions {
1496        static instance: ExtensionRangeOptions = ExtensionRangeOptions {
1497            uninterpreted_option: ::std::vec::Vec::new(),
1498            special_fields: crate::SpecialFields::new(),
1499        };
1500        &instance
1501    }
1502}
1503
1504impl crate::MessageFull for ExtensionRangeOptions {
1505    fn descriptor() -> crate::reflect::MessageDescriptor {
1506        static descriptor: crate::rt::Lazy<crate::reflect::MessageDescriptor> = crate::rt::Lazy::new();
1507        descriptor.get(|| file_descriptor().message_by_package_relative_name("ExtensionRangeOptions").unwrap()).clone()
1508    }
1509}
1510
1511impl ::std::fmt::Display for ExtensionRangeOptions {
1512    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1513        crate::text_format::fmt(self, f)
1514    }
1515}
1516
1517impl crate::reflect::ProtobufValue for ExtensionRangeOptions {
1518    type RuntimeType = crate::reflect::rt::RuntimeTypeMessage<Self>;
1519}
1520
1521///  Describes a field within a message.
1522// @@protoc_insertion_point(message:google.protobuf.FieldDescriptorProto)
1523#[derive(PartialEq,Clone,Default,Debug)]
1524pub struct FieldDescriptorProto {
1525    // message fields
1526    // @@protoc_insertion_point(field:google.protobuf.FieldDescriptorProto.name)
1527    pub name: ::std::option::Option<::std::string::String>,
1528    // @@protoc_insertion_point(field:google.protobuf.FieldDescriptorProto.number)
1529    pub number: ::std::option::Option<i32>,
1530    // @@protoc_insertion_point(field:google.protobuf.FieldDescriptorProto.label)
1531    pub label: ::std::option::Option<crate::EnumOrUnknown<field_descriptor_proto::Label>>,
1532    ///  If type_name is set, this need not be set.  If both this and type_name
1533    ///  are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP.
1534    // @@protoc_insertion_point(field:google.protobuf.FieldDescriptorProto.type)
1535    pub type_: ::std::option::Option<crate::EnumOrUnknown<field_descriptor_proto::Type>>,
1536    ///  For message and enum types, this is the name of the type.  If the name
1537    ///  starts with a '.', it is fully-qualified.  Otherwise, C++-like scoping
1538    ///  rules are used to find the type (i.e. first the nested types within this
1539    ///  message are searched, then within the parent, on up to the root
1540    ///  namespace).
1541    // @@protoc_insertion_point(field:google.protobuf.FieldDescriptorProto.type_name)
1542    pub type_name: ::std::option::Option<::std::string::String>,
1543    ///  For extensions, this is the name of the type being extended.  It is
1544    ///  resolved in the same manner as type_name.
1545    // @@protoc_insertion_point(field:google.protobuf.FieldDescriptorProto.extendee)
1546    pub extendee: ::std::option::Option<::std::string::String>,
1547    ///  For numeric types, contains the original text representation of the value.
1548    ///  For booleans, "true" or "false".
1549    ///  For strings, contains the default text contents (not escaped in any way).
1550    ///  For bytes, contains the C escaped value.  All bytes >= 128 are escaped.
1551    ///  TODO(kenton):  Base-64 encode?
1552    // @@protoc_insertion_point(field:google.protobuf.FieldDescriptorProto.default_value)
1553    pub default_value: ::std::option::Option<::std::string::String>,
1554    ///  If set, gives the index of a oneof in the containing type's oneof_decl
1555    ///  list.  This field is a member of that oneof.
1556    // @@protoc_insertion_point(field:google.protobuf.FieldDescriptorProto.oneof_index)
1557    pub oneof_index: ::std::option::Option<i32>,
1558    ///  JSON name of this field. The value is set by protocol compiler. If the
1559    ///  user has set a "json_name" option on this field, that option's value
1560    ///  will be used. Otherwise, it's deduced from the field's name by converting
1561    ///  it to camelCase.
1562    // @@protoc_insertion_point(field:google.protobuf.FieldDescriptorProto.json_name)
1563    pub json_name: ::std::option::Option<::std::string::String>,
1564    // @@protoc_insertion_point(field:google.protobuf.FieldDescriptorProto.options)
1565    pub options: crate::MessageField<FieldOptions>,
1566    ///  If true, this is a proto3 "optional". When a proto3 field is optional, it
1567    ///  tracks presence regardless of field type.
1568    ///
1569    ///  When proto3_optional is true, this field must be belong to a oneof to
1570    ///  signal to old proto3 clients that presence is tracked for this field. This
1571    ///  oneof is known as a "synthetic" oneof, and this field must be its sole
1572    ///  member (each proto3 optional field gets its own synthetic oneof). Synthetic
1573    ///  oneofs exist in the descriptor only, and do not generate any API. Synthetic
1574    ///  oneofs must be ordered after all "real" oneofs.
1575    ///
1576    ///  For message fields, proto3_optional doesn't create any semantic change,
1577    ///  since non-repeated message fields always track presence. However it still
1578    ///  indicates the semantic detail of whether the user wrote "optional" or not.
1579    ///  This can be useful for round-tripping the .proto file. For consistency we
1580    ///  give message fields a synthetic oneof also, even though it is not required
1581    ///  to track presence. This is especially important because the parser can't
1582    ///  tell if a field is a message or an enum, so it must always create a
1583    ///  synthetic oneof.
1584    ///
1585    ///  Proto2 optional fields do not set this flag, because they already indicate
1586    ///  optional with `LABEL_OPTIONAL`.
1587    // @@protoc_insertion_point(field:google.protobuf.FieldDescriptorProto.proto3_optional)
1588    pub proto3_optional: ::std::option::Option<bool>,
1589    // special fields
1590    // @@protoc_insertion_point(special_field:google.protobuf.FieldDescriptorProto.special_fields)
1591    pub special_fields: crate::SpecialFields,
1592}
1593
1594impl<'a> ::std::default::Default for &'a FieldDescriptorProto {
1595    fn default() -> &'a FieldDescriptorProto {
1596        <FieldDescriptorProto as crate::Message>::default_instance()
1597    }
1598}
1599
1600impl FieldDescriptorProto {
1601    pub fn new() -> FieldDescriptorProto {
1602        ::std::default::Default::default()
1603    }
1604
1605    // optional string name = 1;
1606
1607    pub fn name(&self) -> &str {
1608        match self.name.as_ref() {
1609            Some(v) => v,
1610            None => "",
1611        }
1612    }
1613
1614    pub fn clear_name(&mut self) {
1615        self.name = ::std::option::Option::None;
1616    }
1617
1618    pub fn has_name(&self) -> bool {
1619        self.name.is_some()
1620    }
1621
1622    // Param is passed by value, moved
1623    pub fn set_name(&mut self, v: ::std::string::String) {
1624        self.name = ::std::option::Option::Some(v);
1625    }
1626
1627    // Mutable pointer to the field.
1628    // If field is not initialized, it is initialized with default value first.
1629    pub fn mut_name(&mut self) -> &mut ::std::string::String {
1630        if self.name.is_none() {
1631            self.name = ::std::option::Option::Some(::std::string::String::new());
1632        }
1633        self.name.as_mut().unwrap()
1634    }
1635
1636    // Take field
1637    pub fn take_name(&mut self) -> ::std::string::String {
1638        self.name.take().unwrap_or_else(|| ::std::string::String::new())
1639    }
1640
1641    // optional int32 number = 3;
1642
1643    pub fn number(&self) -> i32 {
1644        self.number.unwrap_or(0)
1645    }
1646
1647    pub fn clear_number(&mut self) {
1648        self.number = ::std::option::Option::None;
1649    }
1650
1651    pub fn has_number(&self) -> bool {
1652        self.number.is_some()
1653    }
1654
1655    // Param is passed by value, moved
1656    pub fn set_number(&mut self, v: i32) {
1657        self.number = ::std::option::Option::Some(v);
1658    }
1659
1660    // optional .google.protobuf.FieldDescriptorProto.Label label = 4;
1661
1662    pub fn label(&self) -> field_descriptor_proto::Label {
1663        match self.label {
1664            Some(e) => e.enum_value_or(field_descriptor_proto::Label::LABEL_OPTIONAL),
1665            None => field_descriptor_proto::Label::LABEL_OPTIONAL,
1666        }
1667    }
1668
1669    pub fn clear_label(&mut self) {
1670        self.label = ::std::option::Option::None;
1671    }
1672
1673    pub fn has_label(&self) -> bool {
1674        self.label.is_some()
1675    }
1676
1677    // Param is passed by value, moved
1678    pub fn set_label(&mut self, v: field_descriptor_proto::Label) {
1679        self.label = ::std::option::Option::Some(crate::EnumOrUnknown::new(v));
1680    }
1681
1682    // optional .google.protobuf.FieldDescriptorProto.Type type = 5;
1683
1684    pub fn type_(&self) -> field_descriptor_proto::Type {
1685        match self.type_ {
1686            Some(e) => e.enum_value_or(field_descriptor_proto::Type::TYPE_DOUBLE),
1687            None => field_descriptor_proto::Type::TYPE_DOUBLE,
1688        }
1689    }
1690
1691    pub fn clear_type_(&mut self) {
1692        self.type_ = ::std::option::Option::None;
1693    }
1694
1695    pub fn has_type(&self) -> bool {
1696        self.type_.is_some()
1697    }
1698
1699    // Param is passed by value, moved
1700    pub fn set_type(&mut self, v: field_descriptor_proto::Type) {
1701        self.type_ = ::std::option::Option::Some(crate::EnumOrUnknown::new(v));
1702    }
1703
1704    // optional string type_name = 6;
1705
1706    pub fn type_name(&self) -> &str {
1707        match self.type_name.as_ref() {
1708            Some(v) => v,
1709            None => "",
1710        }
1711    }
1712
1713    pub fn clear_type_name(&mut self) {
1714        self.type_name = ::std::option::Option::None;
1715    }
1716
1717    pub fn has_type_name(&self) -> bool {
1718        self.type_name.is_some()
1719    }
1720
1721    // Param is passed by value, moved
1722    pub fn set_type_name(&mut self, v: ::std::string::String) {
1723        self.type_name = ::std::option::Option::Some(v);
1724    }
1725
1726    // Mutable pointer to the field.
1727    // If field is not initialized, it is initialized with default value first.
1728    pub fn mut_type_name(&mut self) -> &mut ::std::string::String {
1729        if self.type_name.is_none() {
1730            self.type_name = ::std::option::Option::Some(::std::string::String::new());
1731        }
1732        self.type_name.as_mut().unwrap()
1733    }
1734
1735    // Take field
1736    pub fn take_type_name(&mut self) -> ::std::string::String {
1737        self.type_name.take().unwrap_or_else(|| ::std::string::String::new())
1738    }
1739
1740    // optional string extendee = 2;
1741
1742    pub fn extendee(&self) -> &str {
1743        match self.extendee.as_ref() {
1744            Some(v) => v,
1745            None => "",
1746        }
1747    }
1748
1749    pub fn clear_extendee(&mut self) {
1750        self.extendee = ::std::option::Option::None;
1751    }
1752
1753    pub fn has_extendee(&self) -> bool {
1754        self.extendee.is_some()
1755    }
1756
1757    // Param is passed by value, moved
1758    pub fn set_extendee(&mut self, v: ::std::string::String) {
1759        self.extendee = ::std::option::Option::Some(v);
1760    }
1761
1762    // Mutable pointer to the field.
1763    // If field is not initialized, it is initialized with default value first.
1764    pub fn mut_extendee(&mut self) -> &mut ::std::string::String {
1765        if self.extendee.is_none() {
1766            self.extendee = ::std::option::Option::Some(::std::string::String::new());
1767        }
1768        self.extendee.as_mut().unwrap()
1769    }
1770
1771    // Take field
1772    pub fn take_extendee(&mut self) -> ::std::string::String {
1773        self.extendee.take().unwrap_or_else(|| ::std::string::String::new())
1774    }
1775
1776    // optional string default_value = 7;
1777
1778    pub fn default_value(&self) -> &str {
1779        match self.default_value.as_ref() {
1780            Some(v) => v,
1781            None => "",
1782        }
1783    }
1784
1785    pub fn clear_default_value(&mut self) {
1786        self.default_value = ::std::option::Option::None;
1787    }
1788
1789    pub fn has_default_value(&self) -> bool {
1790        self.default_value.is_some()
1791    }
1792
1793    // Param is passed by value, moved
1794    pub fn set_default_value(&mut self, v: ::std::string::String) {
1795        self.default_value = ::std::option::Option::Some(v);
1796    }
1797
1798    // Mutable pointer to the field.
1799    // If field is not initialized, it is initialized with default value first.
1800    pub fn mut_default_value(&mut self) -> &mut ::std::string::String {
1801        if self.default_value.is_none() {
1802            self.default_value = ::std::option::Option::Some(::std::string::String::new());
1803        }
1804        self.default_value.as_mut().unwrap()
1805    }
1806
1807    // Take field
1808    pub fn take_default_value(&mut self) -> ::std::string::String {
1809        self.default_value.take().unwrap_or_else(|| ::std::string::String::new())
1810    }
1811
1812    // optional int32 oneof_index = 9;
1813
1814    pub fn oneof_index(&self) -> i32 {
1815        self.oneof_index.unwrap_or(0)
1816    }
1817
1818    pub fn clear_oneof_index(&mut self) {
1819        self.oneof_index = ::std::option::Option::None;
1820    }
1821
1822    pub fn has_oneof_index(&self) -> bool {
1823        self.oneof_index.is_some()
1824    }
1825
1826    // Param is passed by value, moved
1827    pub fn set_oneof_index(&mut self, v: i32) {
1828        self.oneof_index = ::std::option::Option::Some(v);
1829    }
1830
1831    // optional string json_name = 10;
1832
1833    pub fn json_name(&self) -> &str {
1834        match self.json_name.as_ref() {
1835            Some(v) => v,
1836            None => "",
1837        }
1838    }
1839
1840    pub fn clear_json_name(&mut self) {
1841        self.json_name = ::std::option::Option::None;
1842    }
1843
1844    pub fn has_json_name(&self) -> bool {
1845        self.json_name.is_some()
1846    }
1847
1848    // Param is passed by value, moved
1849    pub fn set_json_name(&mut self, v: ::std::string::String) {
1850        self.json_name = ::std::option::Option::Some(v);
1851    }
1852
1853    // Mutable pointer to the field.
1854    // If field is not initialized, it is initialized with default value first.
1855    pub fn mut_json_name(&mut self) -> &mut ::std::string::String {
1856        if self.json_name.is_none() {
1857            self.json_name = ::std::option::Option::Some(::std::string::String::new());
1858        }
1859        self.json_name.as_mut().unwrap()
1860    }
1861
1862    // Take field
1863    pub fn take_json_name(&mut self) -> ::std::string::String {
1864        self.json_name.take().unwrap_or_else(|| ::std::string::String::new())
1865    }
1866
1867    // optional bool proto3_optional = 17;
1868
1869    pub fn proto3_optional(&self) -> bool {
1870        self.proto3_optional.unwrap_or(false)
1871    }
1872
1873    pub fn clear_proto3_optional(&mut self) {
1874        self.proto3_optional = ::std::option::Option::None;
1875    }
1876
1877    pub fn has_proto3_optional(&self) -> bool {
1878        self.proto3_optional.is_some()
1879    }
1880
1881    // Param is passed by value, moved
1882    pub fn set_proto3_optional(&mut self, v: bool) {
1883        self.proto3_optional = ::std::option::Option::Some(v);
1884    }
1885
1886    fn generated_message_descriptor_data() -> crate::reflect::GeneratedMessageDescriptorData {
1887        let mut fields = ::std::vec::Vec::with_capacity(11);
1888        let mut oneofs = ::std::vec::Vec::with_capacity(0);
1889        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
1890            "name",
1891            |m: &FieldDescriptorProto| { &m.name },
1892            |m: &mut FieldDescriptorProto| { &mut m.name },
1893        ));
1894        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
1895            "number",
1896            |m: &FieldDescriptorProto| { &m.number },
1897            |m: &mut FieldDescriptorProto| { &mut m.number },
1898        ));
1899        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
1900            "label",
1901            |m: &FieldDescriptorProto| { &m.label },
1902            |m: &mut FieldDescriptorProto| { &mut m.label },
1903        ));
1904        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
1905            "type",
1906            |m: &FieldDescriptorProto| { &m.type_ },
1907            |m: &mut FieldDescriptorProto| { &mut m.type_ },
1908        ));
1909        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
1910            "type_name",
1911            |m: &FieldDescriptorProto| { &m.type_name },
1912            |m: &mut FieldDescriptorProto| { &mut m.type_name },
1913        ));
1914        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
1915            "extendee",
1916            |m: &FieldDescriptorProto| { &m.extendee },
1917            |m: &mut FieldDescriptorProto| { &mut m.extendee },
1918        ));
1919        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
1920            "default_value",
1921            |m: &FieldDescriptorProto| { &m.default_value },
1922            |m: &mut FieldDescriptorProto| { &mut m.default_value },
1923        ));
1924        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
1925            "oneof_index",
1926            |m: &FieldDescriptorProto| { &m.oneof_index },
1927            |m: &mut FieldDescriptorProto| { &mut m.oneof_index },
1928        ));
1929        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
1930            "json_name",
1931            |m: &FieldDescriptorProto| { &m.json_name },
1932            |m: &mut FieldDescriptorProto| { &mut m.json_name },
1933        ));
1934        fields.push(crate::reflect::rt::v2::make_message_field_accessor::<_, FieldOptions>(
1935            "options",
1936            |m: &FieldDescriptorProto| { &m.options },
1937            |m: &mut FieldDescriptorProto| { &mut m.options },
1938        ));
1939        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
1940            "proto3_optional",
1941            |m: &FieldDescriptorProto| { &m.proto3_optional },
1942            |m: &mut FieldDescriptorProto| { &mut m.proto3_optional },
1943        ));
1944        crate::reflect::GeneratedMessageDescriptorData::new_2::<FieldDescriptorProto>(
1945            "FieldDescriptorProto",
1946            fields,
1947            oneofs,
1948        )
1949    }
1950}
1951
1952impl crate::Message for FieldDescriptorProto {
1953    const NAME: &'static str = "FieldDescriptorProto";
1954
1955    fn is_initialized(&self) -> bool {
1956        for v in &self.options {
1957            if !v.is_initialized() {
1958                return false;
1959            }
1960        };
1961        true
1962    }
1963
1964    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::Result<()> {
1965        while let Some(tag) = is.read_raw_tag_or_eof()? {
1966            match tag {
1967                10 => {
1968                    self.name = ::std::option::Option::Some(is.read_string()?);
1969                },
1970                24 => {
1971                    self.number = ::std::option::Option::Some(is.read_int32()?);
1972                },
1973                32 => {
1974                    self.label = ::std::option::Option::Some(is.read_enum_or_unknown()?);
1975                },
1976                40 => {
1977                    self.type_ = ::std::option::Option::Some(is.read_enum_or_unknown()?);
1978                },
1979                50 => {
1980                    self.type_name = ::std::option::Option::Some(is.read_string()?);
1981                },
1982                18 => {
1983                    self.extendee = ::std::option::Option::Some(is.read_string()?);
1984                },
1985                58 => {
1986                    self.default_value = ::std::option::Option::Some(is.read_string()?);
1987                },
1988                72 => {
1989                    self.oneof_index = ::std::option::Option::Some(is.read_int32()?);
1990                },
1991                82 => {
1992                    self.json_name = ::std::option::Option::Some(is.read_string()?);
1993                },
1994                66 => {
1995                    crate::rt::read_singular_message_into_field(is, &mut self.options)?;
1996                },
1997                136 => {
1998                    self.proto3_optional = ::std::option::Option::Some(is.read_bool()?);
1999                },
2000                tag => {
2001                    crate::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
2002                },
2003            };
2004        }
2005        ::std::result::Result::Ok(())
2006    }
2007
2008    // Compute sizes of nested messages
2009    #[allow(unused_variables)]
2010    fn compute_size(&self) -> u64 {
2011        let mut my_size = 0;
2012        if let Some(v) = self.name.as_ref() {
2013            my_size += crate::rt::string_size(1, &v);
2014        }
2015        if let Some(v) = self.number {
2016            my_size += crate::rt::int32_size(3, v);
2017        }
2018        if let Some(v) = self.label {
2019            my_size += crate::rt::int32_size(4, v.value());
2020        }
2021        if let Some(v) = self.type_ {
2022            my_size += crate::rt::int32_size(5, v.value());
2023        }
2024        if let Some(v) = self.type_name.as_ref() {
2025            my_size += crate::rt::string_size(6, &v);
2026        }
2027        if let Some(v) = self.extendee.as_ref() {
2028            my_size += crate::rt::string_size(2, &v);
2029        }
2030        if let Some(v) = self.default_value.as_ref() {
2031            my_size += crate::rt::string_size(7, &v);
2032        }
2033        if let Some(v) = self.oneof_index {
2034            my_size += crate::rt::int32_size(9, v);
2035        }
2036        if let Some(v) = self.json_name.as_ref() {
2037            my_size += crate::rt::string_size(10, &v);
2038        }
2039        if let Some(v) = self.options.as_ref() {
2040            let len = v.compute_size();
2041            my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len;
2042        }
2043        if let Some(v) = self.proto3_optional {
2044            my_size += 2 + 1;
2045        }
2046        my_size += crate::rt::unknown_fields_size(self.special_fields.unknown_fields());
2047        self.special_fields.cached_size().set(my_size as u32);
2048        my_size
2049    }
2050
2051    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::Result<()> {
2052        if let Some(v) = self.name.as_ref() {
2053            os.write_string(1, v)?;
2054        }
2055        if let Some(v) = self.number {
2056            os.write_int32(3, v)?;
2057        }
2058        if let Some(v) = self.label {
2059            os.write_enum(4, crate::EnumOrUnknown::value(&v))?;
2060        }
2061        if let Some(v) = self.type_ {
2062            os.write_enum(5, crate::EnumOrUnknown::value(&v))?;
2063        }
2064        if let Some(v) = self.type_name.as_ref() {
2065            os.write_string(6, v)?;
2066        }
2067        if let Some(v) = self.extendee.as_ref() {
2068            os.write_string(2, v)?;
2069        }
2070        if let Some(v) = self.default_value.as_ref() {
2071            os.write_string(7, v)?;
2072        }
2073        if let Some(v) = self.oneof_index {
2074            os.write_int32(9, v)?;
2075        }
2076        if let Some(v) = self.json_name.as_ref() {
2077            os.write_string(10, v)?;
2078        }
2079        if let Some(v) = self.options.as_ref() {
2080            crate::rt::write_message_field_with_cached_size(8, v, os)?;
2081        }
2082        if let Some(v) = self.proto3_optional {
2083            os.write_bool(17, v)?;
2084        }
2085        os.write_unknown_fields(self.special_fields.unknown_fields())?;
2086        ::std::result::Result::Ok(())
2087    }
2088
2089    fn special_fields(&self) -> &crate::SpecialFields {
2090        &self.special_fields
2091    }
2092
2093    fn mut_special_fields(&mut self) -> &mut crate::SpecialFields {
2094        &mut self.special_fields
2095    }
2096
2097    fn new() -> FieldDescriptorProto {
2098        FieldDescriptorProto::new()
2099    }
2100
2101    fn clear(&mut self) {
2102        self.name = ::std::option::Option::None;
2103        self.number = ::std::option::Option::None;
2104        self.label = ::std::option::Option::None;
2105        self.type_ = ::std::option::Option::None;
2106        self.type_name = ::std::option::Option::None;
2107        self.extendee = ::std::option::Option::None;
2108        self.default_value = ::std::option::Option::None;
2109        self.oneof_index = ::std::option::Option::None;
2110        self.json_name = ::std::option::Option::None;
2111        self.options.clear();
2112        self.proto3_optional = ::std::option::Option::None;
2113        self.special_fields.clear();
2114    }
2115
2116    fn default_instance() -> &'static FieldDescriptorProto {
2117        static instance: FieldDescriptorProto = FieldDescriptorProto {
2118            name: ::std::option::Option::None,
2119            number: ::std::option::Option::None,
2120            label: ::std::option::Option::None,
2121            type_: ::std::option::Option::None,
2122            type_name: ::std::option::Option::None,
2123            extendee: ::std::option::Option::None,
2124            default_value: ::std::option::Option::None,
2125            oneof_index: ::std::option::Option::None,
2126            json_name: ::std::option::Option::None,
2127            options: crate::MessageField::none(),
2128            proto3_optional: ::std::option::Option::None,
2129            special_fields: crate::SpecialFields::new(),
2130        };
2131        &instance
2132    }
2133}
2134
2135impl crate::MessageFull for FieldDescriptorProto {
2136    fn descriptor() -> crate::reflect::MessageDescriptor {
2137        static descriptor: crate::rt::Lazy<crate::reflect::MessageDescriptor> = crate::rt::Lazy::new();
2138        descriptor.get(|| file_descriptor().message_by_package_relative_name("FieldDescriptorProto").unwrap()).clone()
2139    }
2140}
2141
2142impl ::std::fmt::Display for FieldDescriptorProto {
2143    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2144        crate::text_format::fmt(self, f)
2145    }
2146}
2147
2148impl crate::reflect::ProtobufValue for FieldDescriptorProto {
2149    type RuntimeType = crate::reflect::rt::RuntimeTypeMessage<Self>;
2150}
2151
2152/// Nested message and enums of message `FieldDescriptorProto`
2153pub mod field_descriptor_proto {
2154    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
2155    // @@protoc_insertion_point(enum:google.protobuf.FieldDescriptorProto.Type)
2156    pub enum Type {
2157        // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_DOUBLE)
2158        TYPE_DOUBLE = 1,
2159        // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_FLOAT)
2160        TYPE_FLOAT = 2,
2161        // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_INT64)
2162        TYPE_INT64 = 3,
2163        // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_UINT64)
2164        TYPE_UINT64 = 4,
2165        // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_INT32)
2166        TYPE_INT32 = 5,
2167        // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_FIXED64)
2168        TYPE_FIXED64 = 6,
2169        // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_FIXED32)
2170        TYPE_FIXED32 = 7,
2171        // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_BOOL)
2172        TYPE_BOOL = 8,
2173        // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_STRING)
2174        TYPE_STRING = 9,
2175        // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_GROUP)
2176        TYPE_GROUP = 10,
2177        // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_MESSAGE)
2178        TYPE_MESSAGE = 11,
2179        // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_BYTES)
2180        TYPE_BYTES = 12,
2181        // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_UINT32)
2182        TYPE_UINT32 = 13,
2183        // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_ENUM)
2184        TYPE_ENUM = 14,
2185        // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_SFIXED32)
2186        TYPE_SFIXED32 = 15,
2187        // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_SFIXED64)
2188        TYPE_SFIXED64 = 16,
2189        // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_SINT32)
2190        TYPE_SINT32 = 17,
2191        // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Type.TYPE_SINT64)
2192        TYPE_SINT64 = 18,
2193    }
2194
2195    impl crate::Enum for Type {
2196        const NAME: &'static str = "Type";
2197
2198        fn value(&self) -> i32 {
2199            *self as i32
2200        }
2201
2202        fn from_i32(value: i32) -> ::std::option::Option<Type> {
2203            match value {
2204                1 => ::std::option::Option::Some(Type::TYPE_DOUBLE),
2205                2 => ::std::option::Option::Some(Type::TYPE_FLOAT),
2206                3 => ::std::option::Option::Some(Type::TYPE_INT64),
2207                4 => ::std::option::Option::Some(Type::TYPE_UINT64),
2208                5 => ::std::option::Option::Some(Type::TYPE_INT32),
2209                6 => ::std::option::Option::Some(Type::TYPE_FIXED64),
2210                7 => ::std::option::Option::Some(Type::TYPE_FIXED32),
2211                8 => ::std::option::Option::Some(Type::TYPE_BOOL),
2212                9 => ::std::option::Option::Some(Type::TYPE_STRING),
2213                10 => ::std::option::Option::Some(Type::TYPE_GROUP),
2214                11 => ::std::option::Option::Some(Type::TYPE_MESSAGE),
2215                12 => ::std::option::Option::Some(Type::TYPE_BYTES),
2216                13 => ::std::option::Option::Some(Type::TYPE_UINT32),
2217                14 => ::std::option::Option::Some(Type::TYPE_ENUM),
2218                15 => ::std::option::Option::Some(Type::TYPE_SFIXED32),
2219                16 => ::std::option::Option::Some(Type::TYPE_SFIXED64),
2220                17 => ::std::option::Option::Some(Type::TYPE_SINT32),
2221                18 => ::std::option::Option::Some(Type::TYPE_SINT64),
2222                _ => ::std::option::Option::None
2223            }
2224        }
2225
2226        fn from_str(str: &str) -> ::std::option::Option<Type> {
2227            match str {
2228                "TYPE_DOUBLE" => ::std::option::Option::Some(Type::TYPE_DOUBLE),
2229                "TYPE_FLOAT" => ::std::option::Option::Some(Type::TYPE_FLOAT),
2230                "TYPE_INT64" => ::std::option::Option::Some(Type::TYPE_INT64),
2231                "TYPE_UINT64" => ::std::option::Option::Some(Type::TYPE_UINT64),
2232                "TYPE_INT32" => ::std::option::Option::Some(Type::TYPE_INT32),
2233                "TYPE_FIXED64" => ::std::option::Option::Some(Type::TYPE_FIXED64),
2234                "TYPE_FIXED32" => ::std::option::Option::Some(Type::TYPE_FIXED32),
2235                "TYPE_BOOL" => ::std::option::Option::Some(Type::TYPE_BOOL),
2236                "TYPE_STRING" => ::std::option::Option::Some(Type::TYPE_STRING),
2237                "TYPE_GROUP" => ::std::option::Option::Some(Type::TYPE_GROUP),
2238                "TYPE_MESSAGE" => ::std::option::Option::Some(Type::TYPE_MESSAGE),
2239                "TYPE_BYTES" => ::std::option::Option::Some(Type::TYPE_BYTES),
2240                "TYPE_UINT32" => ::std::option::Option::Some(Type::TYPE_UINT32),
2241                "TYPE_ENUM" => ::std::option::Option::Some(Type::TYPE_ENUM),
2242                "TYPE_SFIXED32" => ::std::option::Option::Some(Type::TYPE_SFIXED32),
2243                "TYPE_SFIXED64" => ::std::option::Option::Some(Type::TYPE_SFIXED64),
2244                "TYPE_SINT32" => ::std::option::Option::Some(Type::TYPE_SINT32),
2245                "TYPE_SINT64" => ::std::option::Option::Some(Type::TYPE_SINT64),
2246                _ => ::std::option::Option::None
2247            }
2248        }
2249
2250        const VALUES: &'static [Type] = &[
2251            Type::TYPE_DOUBLE,
2252            Type::TYPE_FLOAT,
2253            Type::TYPE_INT64,
2254            Type::TYPE_UINT64,
2255            Type::TYPE_INT32,
2256            Type::TYPE_FIXED64,
2257            Type::TYPE_FIXED32,
2258            Type::TYPE_BOOL,
2259            Type::TYPE_STRING,
2260            Type::TYPE_GROUP,
2261            Type::TYPE_MESSAGE,
2262            Type::TYPE_BYTES,
2263            Type::TYPE_UINT32,
2264            Type::TYPE_ENUM,
2265            Type::TYPE_SFIXED32,
2266            Type::TYPE_SFIXED64,
2267            Type::TYPE_SINT32,
2268            Type::TYPE_SINT64,
2269        ];
2270    }
2271
2272    impl crate::EnumFull for Type {
2273        fn enum_descriptor() -> crate::reflect::EnumDescriptor {
2274            static descriptor: crate::rt::Lazy<crate::reflect::EnumDescriptor> = crate::rt::Lazy::new();
2275            descriptor.get(|| super::file_descriptor().enum_by_package_relative_name("FieldDescriptorProto.Type").unwrap()).clone()
2276        }
2277
2278        fn descriptor(&self) -> crate::reflect::EnumValueDescriptor {
2279            let index = match self {
2280                Type::TYPE_DOUBLE => 0,
2281                Type::TYPE_FLOAT => 1,
2282                Type::TYPE_INT64 => 2,
2283                Type::TYPE_UINT64 => 3,
2284                Type::TYPE_INT32 => 4,
2285                Type::TYPE_FIXED64 => 5,
2286                Type::TYPE_FIXED32 => 6,
2287                Type::TYPE_BOOL => 7,
2288                Type::TYPE_STRING => 8,
2289                Type::TYPE_GROUP => 9,
2290                Type::TYPE_MESSAGE => 10,
2291                Type::TYPE_BYTES => 11,
2292                Type::TYPE_UINT32 => 12,
2293                Type::TYPE_ENUM => 13,
2294                Type::TYPE_SFIXED32 => 14,
2295                Type::TYPE_SFIXED64 => 15,
2296                Type::TYPE_SINT32 => 16,
2297                Type::TYPE_SINT64 => 17,
2298            };
2299            Self::enum_descriptor().value_by_index(index)
2300        }
2301    }
2302
2303    // Note, `Default` is implemented although default value is not 0
2304    impl ::std::default::Default for Type {
2305        fn default() -> Self {
2306            Type::TYPE_DOUBLE
2307        }
2308    }
2309
2310    impl Type {
2311        pub(in super) fn generated_enum_descriptor_data() -> crate::reflect::GeneratedEnumDescriptorData {
2312            crate::reflect::GeneratedEnumDescriptorData::new::<Type>("FieldDescriptorProto.Type")
2313        }
2314    }
2315
2316    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
2317    // @@protoc_insertion_point(enum:google.protobuf.FieldDescriptorProto.Label)
2318    pub enum Label {
2319        // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Label.LABEL_OPTIONAL)
2320        LABEL_OPTIONAL = 1,
2321        // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Label.LABEL_REQUIRED)
2322        LABEL_REQUIRED = 2,
2323        // @@protoc_insertion_point(enum_value:google.protobuf.FieldDescriptorProto.Label.LABEL_REPEATED)
2324        LABEL_REPEATED = 3,
2325    }
2326
2327    impl crate::Enum for Label {
2328        const NAME: &'static str = "Label";
2329
2330        fn value(&self) -> i32 {
2331            *self as i32
2332        }
2333
2334        fn from_i32(value: i32) -> ::std::option::Option<Label> {
2335            match value {
2336                1 => ::std::option::Option::Some(Label::LABEL_OPTIONAL),
2337                2 => ::std::option::Option::Some(Label::LABEL_REQUIRED),
2338                3 => ::std::option::Option::Some(Label::LABEL_REPEATED),
2339                _ => ::std::option::Option::None
2340            }
2341        }
2342
2343        fn from_str(str: &str) -> ::std::option::Option<Label> {
2344            match str {
2345                "LABEL_OPTIONAL" => ::std::option::Option::Some(Label::LABEL_OPTIONAL),
2346                "LABEL_REQUIRED" => ::std::option::Option::Some(Label::LABEL_REQUIRED),
2347                "LABEL_REPEATED" => ::std::option::Option::Some(Label::LABEL_REPEATED),
2348                _ => ::std::option::Option::None
2349            }
2350        }
2351
2352        const VALUES: &'static [Label] = &[
2353            Label::LABEL_OPTIONAL,
2354            Label::LABEL_REQUIRED,
2355            Label::LABEL_REPEATED,
2356        ];
2357    }
2358
2359    impl crate::EnumFull for Label {
2360        fn enum_descriptor() -> crate::reflect::EnumDescriptor {
2361            static descriptor: crate::rt::Lazy<crate::reflect::EnumDescriptor> = crate::rt::Lazy::new();
2362            descriptor.get(|| super::file_descriptor().enum_by_package_relative_name("FieldDescriptorProto.Label").unwrap()).clone()
2363        }
2364
2365        fn descriptor(&self) -> crate::reflect::EnumValueDescriptor {
2366            let index = match self {
2367                Label::LABEL_OPTIONAL => 0,
2368                Label::LABEL_REQUIRED => 1,
2369                Label::LABEL_REPEATED => 2,
2370            };
2371            Self::enum_descriptor().value_by_index(index)
2372        }
2373    }
2374
2375    // Note, `Default` is implemented although default value is not 0
2376    impl ::std::default::Default for Label {
2377        fn default() -> Self {
2378            Label::LABEL_OPTIONAL
2379        }
2380    }
2381
2382    impl Label {
2383        pub(in super) fn generated_enum_descriptor_data() -> crate::reflect::GeneratedEnumDescriptorData {
2384            crate::reflect::GeneratedEnumDescriptorData::new::<Label>("FieldDescriptorProto.Label")
2385        }
2386    }
2387}
2388
2389///  Describes a oneof.
2390// @@protoc_insertion_point(message:google.protobuf.OneofDescriptorProto)
2391#[derive(PartialEq,Clone,Default,Debug)]
2392pub struct OneofDescriptorProto {
2393    // message fields
2394    // @@protoc_insertion_point(field:google.protobuf.OneofDescriptorProto.name)
2395    pub name: ::std::option::Option<::std::string::String>,
2396    // @@protoc_insertion_point(field:google.protobuf.OneofDescriptorProto.options)
2397    pub options: crate::MessageField<OneofOptions>,
2398    // special fields
2399    // @@protoc_insertion_point(special_field:google.protobuf.OneofDescriptorProto.special_fields)
2400    pub special_fields: crate::SpecialFields,
2401}
2402
2403impl<'a> ::std::default::Default for &'a OneofDescriptorProto {
2404    fn default() -> &'a OneofDescriptorProto {
2405        <OneofDescriptorProto as crate::Message>::default_instance()
2406    }
2407}
2408
2409impl OneofDescriptorProto {
2410    pub fn new() -> OneofDescriptorProto {
2411        ::std::default::Default::default()
2412    }
2413
2414    // optional string name = 1;
2415
2416    pub fn name(&self) -> &str {
2417        match self.name.as_ref() {
2418            Some(v) => v,
2419            None => "",
2420        }
2421    }
2422
2423    pub fn clear_name(&mut self) {
2424        self.name = ::std::option::Option::None;
2425    }
2426
2427    pub fn has_name(&self) -> bool {
2428        self.name.is_some()
2429    }
2430
2431    // Param is passed by value, moved
2432    pub fn set_name(&mut self, v: ::std::string::String) {
2433        self.name = ::std::option::Option::Some(v);
2434    }
2435
2436    // Mutable pointer to the field.
2437    // If field is not initialized, it is initialized with default value first.
2438    pub fn mut_name(&mut self) -> &mut ::std::string::String {
2439        if self.name.is_none() {
2440            self.name = ::std::option::Option::Some(::std::string::String::new());
2441        }
2442        self.name.as_mut().unwrap()
2443    }
2444
2445    // Take field
2446    pub fn take_name(&mut self) -> ::std::string::String {
2447        self.name.take().unwrap_or_else(|| ::std::string::String::new())
2448    }
2449
2450    fn generated_message_descriptor_data() -> crate::reflect::GeneratedMessageDescriptorData {
2451        let mut fields = ::std::vec::Vec::with_capacity(2);
2452        let mut oneofs = ::std::vec::Vec::with_capacity(0);
2453        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
2454            "name",
2455            |m: &OneofDescriptorProto| { &m.name },
2456            |m: &mut OneofDescriptorProto| { &mut m.name },
2457        ));
2458        fields.push(crate::reflect::rt::v2::make_message_field_accessor::<_, OneofOptions>(
2459            "options",
2460            |m: &OneofDescriptorProto| { &m.options },
2461            |m: &mut OneofDescriptorProto| { &mut m.options },
2462        ));
2463        crate::reflect::GeneratedMessageDescriptorData::new_2::<OneofDescriptorProto>(
2464            "OneofDescriptorProto",
2465            fields,
2466            oneofs,
2467        )
2468    }
2469}
2470
2471impl crate::Message for OneofDescriptorProto {
2472    const NAME: &'static str = "OneofDescriptorProto";
2473
2474    fn is_initialized(&self) -> bool {
2475        for v in &self.options {
2476            if !v.is_initialized() {
2477                return false;
2478            }
2479        };
2480        true
2481    }
2482
2483    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::Result<()> {
2484        while let Some(tag) = is.read_raw_tag_or_eof()? {
2485            match tag {
2486                10 => {
2487                    self.name = ::std::option::Option::Some(is.read_string()?);
2488                },
2489                18 => {
2490                    crate::rt::read_singular_message_into_field(is, &mut self.options)?;
2491                },
2492                tag => {
2493                    crate::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
2494                },
2495            };
2496        }
2497        ::std::result::Result::Ok(())
2498    }
2499
2500    // Compute sizes of nested messages
2501    #[allow(unused_variables)]
2502    fn compute_size(&self) -> u64 {
2503        let mut my_size = 0;
2504        if let Some(v) = self.name.as_ref() {
2505            my_size += crate::rt::string_size(1, &v);
2506        }
2507        if let Some(v) = self.options.as_ref() {
2508            let len = v.compute_size();
2509            my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len;
2510        }
2511        my_size += crate::rt::unknown_fields_size(self.special_fields.unknown_fields());
2512        self.special_fields.cached_size().set(my_size as u32);
2513        my_size
2514    }
2515
2516    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::Result<()> {
2517        if let Some(v) = self.name.as_ref() {
2518            os.write_string(1, v)?;
2519        }
2520        if let Some(v) = self.options.as_ref() {
2521            crate::rt::write_message_field_with_cached_size(2, v, os)?;
2522        }
2523        os.write_unknown_fields(self.special_fields.unknown_fields())?;
2524        ::std::result::Result::Ok(())
2525    }
2526
2527    fn special_fields(&self) -> &crate::SpecialFields {
2528        &self.special_fields
2529    }
2530
2531    fn mut_special_fields(&mut self) -> &mut crate::SpecialFields {
2532        &mut self.special_fields
2533    }
2534
2535    fn new() -> OneofDescriptorProto {
2536        OneofDescriptorProto::new()
2537    }
2538
2539    fn clear(&mut self) {
2540        self.name = ::std::option::Option::None;
2541        self.options.clear();
2542        self.special_fields.clear();
2543    }
2544
2545    fn default_instance() -> &'static OneofDescriptorProto {
2546        static instance: OneofDescriptorProto = OneofDescriptorProto {
2547            name: ::std::option::Option::None,
2548            options: crate::MessageField::none(),
2549            special_fields: crate::SpecialFields::new(),
2550        };
2551        &instance
2552    }
2553}
2554
2555impl crate::MessageFull for OneofDescriptorProto {
2556    fn descriptor() -> crate::reflect::MessageDescriptor {
2557        static descriptor: crate::rt::Lazy<crate::reflect::MessageDescriptor> = crate::rt::Lazy::new();
2558        descriptor.get(|| file_descriptor().message_by_package_relative_name("OneofDescriptorProto").unwrap()).clone()
2559    }
2560}
2561
2562impl ::std::fmt::Display for OneofDescriptorProto {
2563    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2564        crate::text_format::fmt(self, f)
2565    }
2566}
2567
2568impl crate::reflect::ProtobufValue for OneofDescriptorProto {
2569    type RuntimeType = crate::reflect::rt::RuntimeTypeMessage<Self>;
2570}
2571
2572///  Describes an enum type.
2573// @@protoc_insertion_point(message:google.protobuf.EnumDescriptorProto)
2574#[derive(PartialEq,Clone,Default,Debug)]
2575pub struct EnumDescriptorProto {
2576    // message fields
2577    // @@protoc_insertion_point(field:google.protobuf.EnumDescriptorProto.name)
2578    pub name: ::std::option::Option<::std::string::String>,
2579    // @@protoc_insertion_point(field:google.protobuf.EnumDescriptorProto.value)
2580    pub value: ::std::vec::Vec<EnumValueDescriptorProto>,
2581    // @@protoc_insertion_point(field:google.protobuf.EnumDescriptorProto.options)
2582    pub options: crate::MessageField<EnumOptions>,
2583    ///  Range of reserved numeric values. Reserved numeric values may not be used
2584    ///  by enum values in the same enum declaration. Reserved ranges may not
2585    ///  overlap.
2586    // @@protoc_insertion_point(field:google.protobuf.EnumDescriptorProto.reserved_range)
2587    pub reserved_range: ::std::vec::Vec<enum_descriptor_proto::EnumReservedRange>,
2588    ///  Reserved enum value names, which may not be reused. A given name may only
2589    ///  be reserved once.
2590    // @@protoc_insertion_point(field:google.protobuf.EnumDescriptorProto.reserved_name)
2591    pub reserved_name: ::std::vec::Vec<::std::string::String>,
2592    // special fields
2593    // @@protoc_insertion_point(special_field:google.protobuf.EnumDescriptorProto.special_fields)
2594    pub special_fields: crate::SpecialFields,
2595}
2596
2597impl<'a> ::std::default::Default for &'a EnumDescriptorProto {
2598    fn default() -> &'a EnumDescriptorProto {
2599        <EnumDescriptorProto as crate::Message>::default_instance()
2600    }
2601}
2602
2603impl EnumDescriptorProto {
2604    pub fn new() -> EnumDescriptorProto {
2605        ::std::default::Default::default()
2606    }
2607
2608    // optional string name = 1;
2609
2610    pub fn name(&self) -> &str {
2611        match self.name.as_ref() {
2612            Some(v) => v,
2613            None => "",
2614        }
2615    }
2616
2617    pub fn clear_name(&mut self) {
2618        self.name = ::std::option::Option::None;
2619    }
2620
2621    pub fn has_name(&self) -> bool {
2622        self.name.is_some()
2623    }
2624
2625    // Param is passed by value, moved
2626    pub fn set_name(&mut self, v: ::std::string::String) {
2627        self.name = ::std::option::Option::Some(v);
2628    }
2629
2630    // Mutable pointer to the field.
2631    // If field is not initialized, it is initialized with default value first.
2632    pub fn mut_name(&mut self) -> &mut ::std::string::String {
2633        if self.name.is_none() {
2634            self.name = ::std::option::Option::Some(::std::string::String::new());
2635        }
2636        self.name.as_mut().unwrap()
2637    }
2638
2639    // Take field
2640    pub fn take_name(&mut self) -> ::std::string::String {
2641        self.name.take().unwrap_or_else(|| ::std::string::String::new())
2642    }
2643
2644    fn generated_message_descriptor_data() -> crate::reflect::GeneratedMessageDescriptorData {
2645        let mut fields = ::std::vec::Vec::with_capacity(5);
2646        let mut oneofs = ::std::vec::Vec::with_capacity(0);
2647        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
2648            "name",
2649            |m: &EnumDescriptorProto| { &m.name },
2650            |m: &mut EnumDescriptorProto| { &mut m.name },
2651        ));
2652        fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
2653            "value",
2654            |m: &EnumDescriptorProto| { &m.value },
2655            |m: &mut EnumDescriptorProto| { &mut m.value },
2656        ));
2657        fields.push(crate::reflect::rt::v2::make_message_field_accessor::<_, EnumOptions>(
2658            "options",
2659            |m: &EnumDescriptorProto| { &m.options },
2660            |m: &mut EnumDescriptorProto| { &mut m.options },
2661        ));
2662        fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
2663            "reserved_range",
2664            |m: &EnumDescriptorProto| { &m.reserved_range },
2665            |m: &mut EnumDescriptorProto| { &mut m.reserved_range },
2666        ));
2667        fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
2668            "reserved_name",
2669            |m: &EnumDescriptorProto| { &m.reserved_name },
2670            |m: &mut EnumDescriptorProto| { &mut m.reserved_name },
2671        ));
2672        crate::reflect::GeneratedMessageDescriptorData::new_2::<EnumDescriptorProto>(
2673            "EnumDescriptorProto",
2674            fields,
2675            oneofs,
2676        )
2677    }
2678}
2679
2680impl crate::Message for EnumDescriptorProto {
2681    const NAME: &'static str = "EnumDescriptorProto";
2682
2683    fn is_initialized(&self) -> bool {
2684        for v in &self.value {
2685            if !v.is_initialized() {
2686                return false;
2687            }
2688        };
2689        for v in &self.options {
2690            if !v.is_initialized() {
2691                return false;
2692            }
2693        };
2694        for v in &self.reserved_range {
2695            if !v.is_initialized() {
2696                return false;
2697            }
2698        };
2699        true
2700    }
2701
2702    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::Result<()> {
2703        while let Some(tag) = is.read_raw_tag_or_eof()? {
2704            match tag {
2705                10 => {
2706                    self.name = ::std::option::Option::Some(is.read_string()?);
2707                },
2708                18 => {
2709                    self.value.push(is.read_message()?);
2710                },
2711                26 => {
2712                    crate::rt::read_singular_message_into_field(is, &mut self.options)?;
2713                },
2714                34 => {
2715                    self.reserved_range.push(is.read_message()?);
2716                },
2717                42 => {
2718                    self.reserved_name.push(is.read_string()?);
2719                },
2720                tag => {
2721                    crate::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
2722                },
2723            };
2724        }
2725        ::std::result::Result::Ok(())
2726    }
2727
2728    // Compute sizes of nested messages
2729    #[allow(unused_variables)]
2730    fn compute_size(&self) -> u64 {
2731        let mut my_size = 0;
2732        if let Some(v) = self.name.as_ref() {
2733            my_size += crate::rt::string_size(1, &v);
2734        }
2735        for value in &self.value {
2736            let len = value.compute_size();
2737            my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len;
2738        };
2739        if let Some(v) = self.options.as_ref() {
2740            let len = v.compute_size();
2741            my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len;
2742        }
2743        for value in &self.reserved_range {
2744            let len = value.compute_size();
2745            my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len;
2746        };
2747        for value in &self.reserved_name {
2748            my_size += crate::rt::string_size(5, &value);
2749        };
2750        my_size += crate::rt::unknown_fields_size(self.special_fields.unknown_fields());
2751        self.special_fields.cached_size().set(my_size as u32);
2752        my_size
2753    }
2754
2755    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::Result<()> {
2756        if let Some(v) = self.name.as_ref() {
2757            os.write_string(1, v)?;
2758        }
2759        for v in &self.value {
2760            crate::rt::write_message_field_with_cached_size(2, v, os)?;
2761        };
2762        if let Some(v) = self.options.as_ref() {
2763            crate::rt::write_message_field_with_cached_size(3, v, os)?;
2764        }
2765        for v in &self.reserved_range {
2766            crate::rt::write_message_field_with_cached_size(4, v, os)?;
2767        };
2768        for v in &self.reserved_name {
2769            os.write_string(5, &v)?;
2770        };
2771        os.write_unknown_fields(self.special_fields.unknown_fields())?;
2772        ::std::result::Result::Ok(())
2773    }
2774
2775    fn special_fields(&self) -> &crate::SpecialFields {
2776        &self.special_fields
2777    }
2778
2779    fn mut_special_fields(&mut self) -> &mut crate::SpecialFields {
2780        &mut self.special_fields
2781    }
2782
2783    fn new() -> EnumDescriptorProto {
2784        EnumDescriptorProto::new()
2785    }
2786
2787    fn clear(&mut self) {
2788        self.name = ::std::option::Option::None;
2789        self.value.clear();
2790        self.options.clear();
2791        self.reserved_range.clear();
2792        self.reserved_name.clear();
2793        self.special_fields.clear();
2794    }
2795
2796    fn default_instance() -> &'static EnumDescriptorProto {
2797        static instance: EnumDescriptorProto = EnumDescriptorProto {
2798            name: ::std::option::Option::None,
2799            value: ::std::vec::Vec::new(),
2800            options: crate::MessageField::none(),
2801            reserved_range: ::std::vec::Vec::new(),
2802            reserved_name: ::std::vec::Vec::new(),
2803            special_fields: crate::SpecialFields::new(),
2804        };
2805        &instance
2806    }
2807}
2808
2809impl crate::MessageFull for EnumDescriptorProto {
2810    fn descriptor() -> crate::reflect::MessageDescriptor {
2811        static descriptor: crate::rt::Lazy<crate::reflect::MessageDescriptor> = crate::rt::Lazy::new();
2812        descriptor.get(|| file_descriptor().message_by_package_relative_name("EnumDescriptorProto").unwrap()).clone()
2813    }
2814}
2815
2816impl ::std::fmt::Display for EnumDescriptorProto {
2817    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2818        crate::text_format::fmt(self, f)
2819    }
2820}
2821
2822impl crate::reflect::ProtobufValue for EnumDescriptorProto {
2823    type RuntimeType = crate::reflect::rt::RuntimeTypeMessage<Self>;
2824}
2825
2826/// Nested message and enums of message `EnumDescriptorProto`
2827pub mod enum_descriptor_proto {
2828    ///  Range of reserved numeric values. Reserved values may not be used by
2829    ///  entries in the same enum. Reserved ranges may not overlap.
2830    ///
2831    ///  Note that this is distinct from DescriptorProto.ReservedRange in that it
2832    ///  is inclusive such that it can appropriately represent the entire int32
2833    ///  domain.
2834    // @@protoc_insertion_point(message:google.protobuf.EnumDescriptorProto.EnumReservedRange)
2835    #[derive(PartialEq,Clone,Default,Debug)]
2836    pub struct EnumReservedRange {
2837        // message fields
2838        // @@protoc_insertion_point(field:google.protobuf.EnumDescriptorProto.EnumReservedRange.start)
2839        pub start: ::std::option::Option<i32>,
2840        // @@protoc_insertion_point(field:google.protobuf.EnumDescriptorProto.EnumReservedRange.end)
2841        pub end: ::std::option::Option<i32>,
2842        // special fields
2843        // @@protoc_insertion_point(special_field:google.protobuf.EnumDescriptorProto.EnumReservedRange.special_fields)
2844        pub special_fields: crate::SpecialFields,
2845    }
2846
2847    impl<'a> ::std::default::Default for &'a EnumReservedRange {
2848        fn default() -> &'a EnumReservedRange {
2849            <EnumReservedRange as crate::Message>::default_instance()
2850        }
2851    }
2852
2853    impl EnumReservedRange {
2854        pub fn new() -> EnumReservedRange {
2855            ::std::default::Default::default()
2856        }
2857
2858        // optional int32 start = 1;
2859
2860        pub fn start(&self) -> i32 {
2861            self.start.unwrap_or(0)
2862        }
2863
2864        pub fn clear_start(&mut self) {
2865            self.start = ::std::option::Option::None;
2866        }
2867
2868        pub fn has_start(&self) -> bool {
2869            self.start.is_some()
2870        }
2871
2872        // Param is passed by value, moved
2873        pub fn set_start(&mut self, v: i32) {
2874            self.start = ::std::option::Option::Some(v);
2875        }
2876
2877        // optional int32 end = 2;
2878
2879        pub fn end(&self) -> i32 {
2880            self.end.unwrap_or(0)
2881        }
2882
2883        pub fn clear_end(&mut self) {
2884            self.end = ::std::option::Option::None;
2885        }
2886
2887        pub fn has_end(&self) -> bool {
2888            self.end.is_some()
2889        }
2890
2891        // Param is passed by value, moved
2892        pub fn set_end(&mut self, v: i32) {
2893            self.end = ::std::option::Option::Some(v);
2894        }
2895
2896        pub(in super) fn generated_message_descriptor_data() -> crate::reflect::GeneratedMessageDescriptorData {
2897            let mut fields = ::std::vec::Vec::with_capacity(2);
2898            let mut oneofs = ::std::vec::Vec::with_capacity(0);
2899            fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
2900                "start",
2901                |m: &EnumReservedRange| { &m.start },
2902                |m: &mut EnumReservedRange| { &mut m.start },
2903            ));
2904            fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
2905                "end",
2906                |m: &EnumReservedRange| { &m.end },
2907                |m: &mut EnumReservedRange| { &mut m.end },
2908            ));
2909            crate::reflect::GeneratedMessageDescriptorData::new_2::<EnumReservedRange>(
2910                "EnumDescriptorProto.EnumReservedRange",
2911                fields,
2912                oneofs,
2913            )
2914        }
2915    }
2916
2917    impl crate::Message for EnumReservedRange {
2918        const NAME: &'static str = "EnumReservedRange";
2919
2920        fn is_initialized(&self) -> bool {
2921            true
2922        }
2923
2924        fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::Result<()> {
2925            while let Some(tag) = is.read_raw_tag_or_eof()? {
2926                match tag {
2927                    8 => {
2928                        self.start = ::std::option::Option::Some(is.read_int32()?);
2929                    },
2930                    16 => {
2931                        self.end = ::std::option::Option::Some(is.read_int32()?);
2932                    },
2933                    tag => {
2934                        crate::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
2935                    },
2936                };
2937            }
2938            ::std::result::Result::Ok(())
2939        }
2940
2941        // Compute sizes of nested messages
2942        #[allow(unused_variables)]
2943        fn compute_size(&self) -> u64 {
2944            let mut my_size = 0;
2945            if let Some(v) = self.start {
2946                my_size += crate::rt::int32_size(1, v);
2947            }
2948            if let Some(v) = self.end {
2949                my_size += crate::rt::int32_size(2, v);
2950            }
2951            my_size += crate::rt::unknown_fields_size(self.special_fields.unknown_fields());
2952            self.special_fields.cached_size().set(my_size as u32);
2953            my_size
2954        }
2955
2956        fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::Result<()> {
2957            if let Some(v) = self.start {
2958                os.write_int32(1, v)?;
2959            }
2960            if let Some(v) = self.end {
2961                os.write_int32(2, v)?;
2962            }
2963            os.write_unknown_fields(self.special_fields.unknown_fields())?;
2964            ::std::result::Result::Ok(())
2965        }
2966
2967        fn special_fields(&self) -> &crate::SpecialFields {
2968            &self.special_fields
2969        }
2970
2971        fn mut_special_fields(&mut self) -> &mut crate::SpecialFields {
2972            &mut self.special_fields
2973        }
2974
2975        fn new() -> EnumReservedRange {
2976            EnumReservedRange::new()
2977        }
2978
2979        fn clear(&mut self) {
2980            self.start = ::std::option::Option::None;
2981            self.end = ::std::option::Option::None;
2982            self.special_fields.clear();
2983        }
2984
2985        fn default_instance() -> &'static EnumReservedRange {
2986            static instance: EnumReservedRange = EnumReservedRange {
2987                start: ::std::option::Option::None,
2988                end: ::std::option::Option::None,
2989                special_fields: crate::SpecialFields::new(),
2990            };
2991            &instance
2992        }
2993    }
2994
2995    impl crate::MessageFull for EnumReservedRange {
2996        fn descriptor() -> crate::reflect::MessageDescriptor {
2997            static descriptor: crate::rt::Lazy<crate::reflect::MessageDescriptor> = crate::rt::Lazy::new();
2998            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("EnumDescriptorProto.EnumReservedRange").unwrap()).clone()
2999        }
3000    }
3001
3002    impl ::std::fmt::Display for EnumReservedRange {
3003        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3004            crate::text_format::fmt(self, f)
3005        }
3006    }
3007
3008    impl crate::reflect::ProtobufValue for EnumReservedRange {
3009        type RuntimeType = crate::reflect::rt::RuntimeTypeMessage<Self>;
3010    }
3011}
3012
3013///  Describes a value within an enum.
3014// @@protoc_insertion_point(message:google.protobuf.EnumValueDescriptorProto)
3015#[derive(PartialEq,Clone,Default,Debug)]
3016pub struct EnumValueDescriptorProto {
3017    // message fields
3018    // @@protoc_insertion_point(field:google.protobuf.EnumValueDescriptorProto.name)
3019    pub name: ::std::option::Option<::std::string::String>,
3020    // @@protoc_insertion_point(field:google.protobuf.EnumValueDescriptorProto.number)
3021    pub number: ::std::option::Option<i32>,
3022    // @@protoc_insertion_point(field:google.protobuf.EnumValueDescriptorProto.options)
3023    pub options: crate::MessageField<EnumValueOptions>,
3024    // special fields
3025    // @@protoc_insertion_point(special_field:google.protobuf.EnumValueDescriptorProto.special_fields)
3026    pub special_fields: crate::SpecialFields,
3027}
3028
3029impl<'a> ::std::default::Default for &'a EnumValueDescriptorProto {
3030    fn default() -> &'a EnumValueDescriptorProto {
3031        <EnumValueDescriptorProto as crate::Message>::default_instance()
3032    }
3033}
3034
3035impl EnumValueDescriptorProto {
3036    pub fn new() -> EnumValueDescriptorProto {
3037        ::std::default::Default::default()
3038    }
3039
3040    // optional string name = 1;
3041
3042    pub fn name(&self) -> &str {
3043        match self.name.as_ref() {
3044            Some(v) => v,
3045            None => "",
3046        }
3047    }
3048
3049    pub fn clear_name(&mut self) {
3050        self.name = ::std::option::Option::None;
3051    }
3052
3053    pub fn has_name(&self) -> bool {
3054        self.name.is_some()
3055    }
3056
3057    // Param is passed by value, moved
3058    pub fn set_name(&mut self, v: ::std::string::String) {
3059        self.name = ::std::option::Option::Some(v);
3060    }
3061
3062    // Mutable pointer to the field.
3063    // If field is not initialized, it is initialized with default value first.
3064    pub fn mut_name(&mut self) -> &mut ::std::string::String {
3065        if self.name.is_none() {
3066            self.name = ::std::option::Option::Some(::std::string::String::new());
3067        }
3068        self.name.as_mut().unwrap()
3069    }
3070
3071    // Take field
3072    pub fn take_name(&mut self) -> ::std::string::String {
3073        self.name.take().unwrap_or_else(|| ::std::string::String::new())
3074    }
3075
3076    // optional int32 number = 2;
3077
3078    pub fn number(&self) -> i32 {
3079        self.number.unwrap_or(0)
3080    }
3081
3082    pub fn clear_number(&mut self) {
3083        self.number = ::std::option::Option::None;
3084    }
3085
3086    pub fn has_number(&self) -> bool {
3087        self.number.is_some()
3088    }
3089
3090    // Param is passed by value, moved
3091    pub fn set_number(&mut self, v: i32) {
3092        self.number = ::std::option::Option::Some(v);
3093    }
3094
3095    fn generated_message_descriptor_data() -> crate::reflect::GeneratedMessageDescriptorData {
3096        let mut fields = ::std::vec::Vec::with_capacity(3);
3097        let mut oneofs = ::std::vec::Vec::with_capacity(0);
3098        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
3099            "name",
3100            |m: &EnumValueDescriptorProto| { &m.name },
3101            |m: &mut EnumValueDescriptorProto| { &mut m.name },
3102        ));
3103        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
3104            "number",
3105            |m: &EnumValueDescriptorProto| { &m.number },
3106            |m: &mut EnumValueDescriptorProto| { &mut m.number },
3107        ));
3108        fields.push(crate::reflect::rt::v2::make_message_field_accessor::<_, EnumValueOptions>(
3109            "options",
3110            |m: &EnumValueDescriptorProto| { &m.options },
3111            |m: &mut EnumValueDescriptorProto| { &mut m.options },
3112        ));
3113        crate::reflect::GeneratedMessageDescriptorData::new_2::<EnumValueDescriptorProto>(
3114            "EnumValueDescriptorProto",
3115            fields,
3116            oneofs,
3117        )
3118    }
3119}
3120
3121impl crate::Message for EnumValueDescriptorProto {
3122    const NAME: &'static str = "EnumValueDescriptorProto";
3123
3124    fn is_initialized(&self) -> bool {
3125        for v in &self.options {
3126            if !v.is_initialized() {
3127                return false;
3128            }
3129        };
3130        true
3131    }
3132
3133    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::Result<()> {
3134        while let Some(tag) = is.read_raw_tag_or_eof()? {
3135            match tag {
3136                10 => {
3137                    self.name = ::std::option::Option::Some(is.read_string()?);
3138                },
3139                16 => {
3140                    self.number = ::std::option::Option::Some(is.read_int32()?);
3141                },
3142                26 => {
3143                    crate::rt::read_singular_message_into_field(is, &mut self.options)?;
3144                },
3145                tag => {
3146                    crate::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
3147                },
3148            };
3149        }
3150        ::std::result::Result::Ok(())
3151    }
3152
3153    // Compute sizes of nested messages
3154    #[allow(unused_variables)]
3155    fn compute_size(&self) -> u64 {
3156        let mut my_size = 0;
3157        if let Some(v) = self.name.as_ref() {
3158            my_size += crate::rt::string_size(1, &v);
3159        }
3160        if let Some(v) = self.number {
3161            my_size += crate::rt::int32_size(2, v);
3162        }
3163        if let Some(v) = self.options.as_ref() {
3164            let len = v.compute_size();
3165            my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len;
3166        }
3167        my_size += crate::rt::unknown_fields_size(self.special_fields.unknown_fields());
3168        self.special_fields.cached_size().set(my_size as u32);
3169        my_size
3170    }
3171
3172    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::Result<()> {
3173        if let Some(v) = self.name.as_ref() {
3174            os.write_string(1, v)?;
3175        }
3176        if let Some(v) = self.number {
3177            os.write_int32(2, v)?;
3178        }
3179        if let Some(v) = self.options.as_ref() {
3180            crate::rt::write_message_field_with_cached_size(3, v, os)?;
3181        }
3182        os.write_unknown_fields(self.special_fields.unknown_fields())?;
3183        ::std::result::Result::Ok(())
3184    }
3185
3186    fn special_fields(&self) -> &crate::SpecialFields {
3187        &self.special_fields
3188    }
3189
3190    fn mut_special_fields(&mut self) -> &mut crate::SpecialFields {
3191        &mut self.special_fields
3192    }
3193
3194    fn new() -> EnumValueDescriptorProto {
3195        EnumValueDescriptorProto::new()
3196    }
3197
3198    fn clear(&mut self) {
3199        self.name = ::std::option::Option::None;
3200        self.number = ::std::option::Option::None;
3201        self.options.clear();
3202        self.special_fields.clear();
3203    }
3204
3205    fn default_instance() -> &'static EnumValueDescriptorProto {
3206        static instance: EnumValueDescriptorProto = EnumValueDescriptorProto {
3207            name: ::std::option::Option::None,
3208            number: ::std::option::Option::None,
3209            options: crate::MessageField::none(),
3210            special_fields: crate::SpecialFields::new(),
3211        };
3212        &instance
3213    }
3214}
3215
3216impl crate::MessageFull for EnumValueDescriptorProto {
3217    fn descriptor() -> crate::reflect::MessageDescriptor {
3218        static descriptor: crate::rt::Lazy<crate::reflect::MessageDescriptor> = crate::rt::Lazy::new();
3219        descriptor.get(|| file_descriptor().message_by_package_relative_name("EnumValueDescriptorProto").unwrap()).clone()
3220    }
3221}
3222
3223impl ::std::fmt::Display for EnumValueDescriptorProto {
3224    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3225        crate::text_format::fmt(self, f)
3226    }
3227}
3228
3229impl crate::reflect::ProtobufValue for EnumValueDescriptorProto {
3230    type RuntimeType = crate::reflect::rt::RuntimeTypeMessage<Self>;
3231}
3232
3233///  Describes a service.
3234// @@protoc_insertion_point(message:google.protobuf.ServiceDescriptorProto)
3235#[derive(PartialEq,Clone,Default,Debug)]
3236pub struct ServiceDescriptorProto {
3237    // message fields
3238    // @@protoc_insertion_point(field:google.protobuf.ServiceDescriptorProto.name)
3239    pub name: ::std::option::Option<::std::string::String>,
3240    // @@protoc_insertion_point(field:google.protobuf.ServiceDescriptorProto.method)
3241    pub method: ::std::vec::Vec<MethodDescriptorProto>,
3242    // @@protoc_insertion_point(field:google.protobuf.ServiceDescriptorProto.options)
3243    pub options: crate::MessageField<ServiceOptions>,
3244    // special fields
3245    // @@protoc_insertion_point(special_field:google.protobuf.ServiceDescriptorProto.special_fields)
3246    pub special_fields: crate::SpecialFields,
3247}
3248
3249impl<'a> ::std::default::Default for &'a ServiceDescriptorProto {
3250    fn default() -> &'a ServiceDescriptorProto {
3251        <ServiceDescriptorProto as crate::Message>::default_instance()
3252    }
3253}
3254
3255impl ServiceDescriptorProto {
3256    pub fn new() -> ServiceDescriptorProto {
3257        ::std::default::Default::default()
3258    }
3259
3260    // optional string name = 1;
3261
3262    pub fn name(&self) -> &str {
3263        match self.name.as_ref() {
3264            Some(v) => v,
3265            None => "",
3266        }
3267    }
3268
3269    pub fn clear_name(&mut self) {
3270        self.name = ::std::option::Option::None;
3271    }
3272
3273    pub fn has_name(&self) -> bool {
3274        self.name.is_some()
3275    }
3276
3277    // Param is passed by value, moved
3278    pub fn set_name(&mut self, v: ::std::string::String) {
3279        self.name = ::std::option::Option::Some(v);
3280    }
3281
3282    // Mutable pointer to the field.
3283    // If field is not initialized, it is initialized with default value first.
3284    pub fn mut_name(&mut self) -> &mut ::std::string::String {
3285        if self.name.is_none() {
3286            self.name = ::std::option::Option::Some(::std::string::String::new());
3287        }
3288        self.name.as_mut().unwrap()
3289    }
3290
3291    // Take field
3292    pub fn take_name(&mut self) -> ::std::string::String {
3293        self.name.take().unwrap_or_else(|| ::std::string::String::new())
3294    }
3295
3296    fn generated_message_descriptor_data() -> crate::reflect::GeneratedMessageDescriptorData {
3297        let mut fields = ::std::vec::Vec::with_capacity(3);
3298        let mut oneofs = ::std::vec::Vec::with_capacity(0);
3299        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
3300            "name",
3301            |m: &ServiceDescriptorProto| { &m.name },
3302            |m: &mut ServiceDescriptorProto| { &mut m.name },
3303        ));
3304        fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
3305            "method",
3306            |m: &ServiceDescriptorProto| { &m.method },
3307            |m: &mut ServiceDescriptorProto| { &mut m.method },
3308        ));
3309        fields.push(crate::reflect::rt::v2::make_message_field_accessor::<_, ServiceOptions>(
3310            "options",
3311            |m: &ServiceDescriptorProto| { &m.options },
3312            |m: &mut ServiceDescriptorProto| { &mut m.options },
3313        ));
3314        crate::reflect::GeneratedMessageDescriptorData::new_2::<ServiceDescriptorProto>(
3315            "ServiceDescriptorProto",
3316            fields,
3317            oneofs,
3318        )
3319    }
3320}
3321
3322impl crate::Message for ServiceDescriptorProto {
3323    const NAME: &'static str = "ServiceDescriptorProto";
3324
3325    fn is_initialized(&self) -> bool {
3326        for v in &self.method {
3327            if !v.is_initialized() {
3328                return false;
3329            }
3330        };
3331        for v in &self.options {
3332            if !v.is_initialized() {
3333                return false;
3334            }
3335        };
3336        true
3337    }
3338
3339    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::Result<()> {
3340        while let Some(tag) = is.read_raw_tag_or_eof()? {
3341            match tag {
3342                10 => {
3343                    self.name = ::std::option::Option::Some(is.read_string()?);
3344                },
3345                18 => {
3346                    self.method.push(is.read_message()?);
3347                },
3348                26 => {
3349                    crate::rt::read_singular_message_into_field(is, &mut self.options)?;
3350                },
3351                tag => {
3352                    crate::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
3353                },
3354            };
3355        }
3356        ::std::result::Result::Ok(())
3357    }
3358
3359    // Compute sizes of nested messages
3360    #[allow(unused_variables)]
3361    fn compute_size(&self) -> u64 {
3362        let mut my_size = 0;
3363        if let Some(v) = self.name.as_ref() {
3364            my_size += crate::rt::string_size(1, &v);
3365        }
3366        for value in &self.method {
3367            let len = value.compute_size();
3368            my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len;
3369        };
3370        if let Some(v) = self.options.as_ref() {
3371            let len = v.compute_size();
3372            my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len;
3373        }
3374        my_size += crate::rt::unknown_fields_size(self.special_fields.unknown_fields());
3375        self.special_fields.cached_size().set(my_size as u32);
3376        my_size
3377    }
3378
3379    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::Result<()> {
3380        if let Some(v) = self.name.as_ref() {
3381            os.write_string(1, v)?;
3382        }
3383        for v in &self.method {
3384            crate::rt::write_message_field_with_cached_size(2, v, os)?;
3385        };
3386        if let Some(v) = self.options.as_ref() {
3387            crate::rt::write_message_field_with_cached_size(3, v, os)?;
3388        }
3389        os.write_unknown_fields(self.special_fields.unknown_fields())?;
3390        ::std::result::Result::Ok(())
3391    }
3392
3393    fn special_fields(&self) -> &crate::SpecialFields {
3394        &self.special_fields
3395    }
3396
3397    fn mut_special_fields(&mut self) -> &mut crate::SpecialFields {
3398        &mut self.special_fields
3399    }
3400
3401    fn new() -> ServiceDescriptorProto {
3402        ServiceDescriptorProto::new()
3403    }
3404
3405    fn clear(&mut self) {
3406        self.name = ::std::option::Option::None;
3407        self.method.clear();
3408        self.options.clear();
3409        self.special_fields.clear();
3410    }
3411
3412    fn default_instance() -> &'static ServiceDescriptorProto {
3413        static instance: ServiceDescriptorProto = ServiceDescriptorProto {
3414            name: ::std::option::Option::None,
3415            method: ::std::vec::Vec::new(),
3416            options: crate::MessageField::none(),
3417            special_fields: crate::SpecialFields::new(),
3418        };
3419        &instance
3420    }
3421}
3422
3423impl crate::MessageFull for ServiceDescriptorProto {
3424    fn descriptor() -> crate::reflect::MessageDescriptor {
3425        static descriptor: crate::rt::Lazy<crate::reflect::MessageDescriptor> = crate::rt::Lazy::new();
3426        descriptor.get(|| file_descriptor().message_by_package_relative_name("ServiceDescriptorProto").unwrap()).clone()
3427    }
3428}
3429
3430impl ::std::fmt::Display for ServiceDescriptorProto {
3431    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3432        crate::text_format::fmt(self, f)
3433    }
3434}
3435
3436impl crate::reflect::ProtobufValue for ServiceDescriptorProto {
3437    type RuntimeType = crate::reflect::rt::RuntimeTypeMessage<Self>;
3438}
3439
3440///  Describes a method of a service.
3441// @@protoc_insertion_point(message:google.protobuf.MethodDescriptorProto)
3442#[derive(PartialEq,Clone,Default,Debug)]
3443pub struct MethodDescriptorProto {
3444    // message fields
3445    // @@protoc_insertion_point(field:google.protobuf.MethodDescriptorProto.name)
3446    pub name: ::std::option::Option<::std::string::String>,
3447    ///  Input and output type names.  These are resolved in the same way as
3448    ///  FieldDescriptorProto.type_name, but must refer to a message type.
3449    // @@protoc_insertion_point(field:google.protobuf.MethodDescriptorProto.input_type)
3450    pub input_type: ::std::option::Option<::std::string::String>,
3451    // @@protoc_insertion_point(field:google.protobuf.MethodDescriptorProto.output_type)
3452    pub output_type: ::std::option::Option<::std::string::String>,
3453    // @@protoc_insertion_point(field:google.protobuf.MethodDescriptorProto.options)
3454    pub options: crate::MessageField<MethodOptions>,
3455    ///  Identifies if client streams multiple client messages
3456    // @@protoc_insertion_point(field:google.protobuf.MethodDescriptorProto.client_streaming)
3457    pub client_streaming: ::std::option::Option<bool>,
3458    ///  Identifies if server streams multiple server messages
3459    // @@protoc_insertion_point(field:google.protobuf.MethodDescriptorProto.server_streaming)
3460    pub server_streaming: ::std::option::Option<bool>,
3461    // special fields
3462    // @@protoc_insertion_point(special_field:google.protobuf.MethodDescriptorProto.special_fields)
3463    pub special_fields: crate::SpecialFields,
3464}
3465
3466impl<'a> ::std::default::Default for &'a MethodDescriptorProto {
3467    fn default() -> &'a MethodDescriptorProto {
3468        <MethodDescriptorProto as crate::Message>::default_instance()
3469    }
3470}
3471
3472impl MethodDescriptorProto {
3473    pub fn new() -> MethodDescriptorProto {
3474        ::std::default::Default::default()
3475    }
3476
3477    // optional string name = 1;
3478
3479    pub fn name(&self) -> &str {
3480        match self.name.as_ref() {
3481            Some(v) => v,
3482            None => "",
3483        }
3484    }
3485
3486    pub fn clear_name(&mut self) {
3487        self.name = ::std::option::Option::None;
3488    }
3489
3490    pub fn has_name(&self) -> bool {
3491        self.name.is_some()
3492    }
3493
3494    // Param is passed by value, moved
3495    pub fn set_name(&mut self, v: ::std::string::String) {
3496        self.name = ::std::option::Option::Some(v);
3497    }
3498
3499    // Mutable pointer to the field.
3500    // If field is not initialized, it is initialized with default value first.
3501    pub fn mut_name(&mut self) -> &mut ::std::string::String {
3502        if self.name.is_none() {
3503            self.name = ::std::option::Option::Some(::std::string::String::new());
3504        }
3505        self.name.as_mut().unwrap()
3506    }
3507
3508    // Take field
3509    pub fn take_name(&mut self) -> ::std::string::String {
3510        self.name.take().unwrap_or_else(|| ::std::string::String::new())
3511    }
3512
3513    // optional string input_type = 2;
3514
3515    pub fn input_type(&self) -> &str {
3516        match self.input_type.as_ref() {
3517            Some(v) => v,
3518            None => "",
3519        }
3520    }
3521
3522    pub fn clear_input_type(&mut self) {
3523        self.input_type = ::std::option::Option::None;
3524    }
3525
3526    pub fn has_input_type(&self) -> bool {
3527        self.input_type.is_some()
3528    }
3529
3530    // Param is passed by value, moved
3531    pub fn set_input_type(&mut self, v: ::std::string::String) {
3532        self.input_type = ::std::option::Option::Some(v);
3533    }
3534
3535    // Mutable pointer to the field.
3536    // If field is not initialized, it is initialized with default value first.
3537    pub fn mut_input_type(&mut self) -> &mut ::std::string::String {
3538        if self.input_type.is_none() {
3539            self.input_type = ::std::option::Option::Some(::std::string::String::new());
3540        }
3541        self.input_type.as_mut().unwrap()
3542    }
3543
3544    // Take field
3545    pub fn take_input_type(&mut self) -> ::std::string::String {
3546        self.input_type.take().unwrap_or_else(|| ::std::string::String::new())
3547    }
3548
3549    // optional string output_type = 3;
3550
3551    pub fn output_type(&self) -> &str {
3552        match self.output_type.as_ref() {
3553            Some(v) => v,
3554            None => "",
3555        }
3556    }
3557
3558    pub fn clear_output_type(&mut self) {
3559        self.output_type = ::std::option::Option::None;
3560    }
3561
3562    pub fn has_output_type(&self) -> bool {
3563        self.output_type.is_some()
3564    }
3565
3566    // Param is passed by value, moved
3567    pub fn set_output_type(&mut self, v: ::std::string::String) {
3568        self.output_type = ::std::option::Option::Some(v);
3569    }
3570
3571    // Mutable pointer to the field.
3572    // If field is not initialized, it is initialized with default value first.
3573    pub fn mut_output_type(&mut self) -> &mut ::std::string::String {
3574        if self.output_type.is_none() {
3575            self.output_type = ::std::option::Option::Some(::std::string::String::new());
3576        }
3577        self.output_type.as_mut().unwrap()
3578    }
3579
3580    // Take field
3581    pub fn take_output_type(&mut self) -> ::std::string::String {
3582        self.output_type.take().unwrap_or_else(|| ::std::string::String::new())
3583    }
3584
3585    // optional bool client_streaming = 5;
3586
3587    pub fn client_streaming(&self) -> bool {
3588        self.client_streaming.unwrap_or(false)
3589    }
3590
3591    pub fn clear_client_streaming(&mut self) {
3592        self.client_streaming = ::std::option::Option::None;
3593    }
3594
3595    pub fn has_client_streaming(&self) -> bool {
3596        self.client_streaming.is_some()
3597    }
3598
3599    // Param is passed by value, moved
3600    pub fn set_client_streaming(&mut self, v: bool) {
3601        self.client_streaming = ::std::option::Option::Some(v);
3602    }
3603
3604    // optional bool server_streaming = 6;
3605
3606    pub fn server_streaming(&self) -> bool {
3607        self.server_streaming.unwrap_or(false)
3608    }
3609
3610    pub fn clear_server_streaming(&mut self) {
3611        self.server_streaming = ::std::option::Option::None;
3612    }
3613
3614    pub fn has_server_streaming(&self) -> bool {
3615        self.server_streaming.is_some()
3616    }
3617
3618    // Param is passed by value, moved
3619    pub fn set_server_streaming(&mut self, v: bool) {
3620        self.server_streaming = ::std::option::Option::Some(v);
3621    }
3622
3623    fn generated_message_descriptor_data() -> crate::reflect::GeneratedMessageDescriptorData {
3624        let mut fields = ::std::vec::Vec::with_capacity(6);
3625        let mut oneofs = ::std::vec::Vec::with_capacity(0);
3626        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
3627            "name",
3628            |m: &MethodDescriptorProto| { &m.name },
3629            |m: &mut MethodDescriptorProto| { &mut m.name },
3630        ));
3631        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
3632            "input_type",
3633            |m: &MethodDescriptorProto| { &m.input_type },
3634            |m: &mut MethodDescriptorProto| { &mut m.input_type },
3635        ));
3636        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
3637            "output_type",
3638            |m: &MethodDescriptorProto| { &m.output_type },
3639            |m: &mut MethodDescriptorProto| { &mut m.output_type },
3640        ));
3641        fields.push(crate::reflect::rt::v2::make_message_field_accessor::<_, MethodOptions>(
3642            "options",
3643            |m: &MethodDescriptorProto| { &m.options },
3644            |m: &mut MethodDescriptorProto| { &mut m.options },
3645        ));
3646        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
3647            "client_streaming",
3648            |m: &MethodDescriptorProto| { &m.client_streaming },
3649            |m: &mut MethodDescriptorProto| { &mut m.client_streaming },
3650        ));
3651        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
3652            "server_streaming",
3653            |m: &MethodDescriptorProto| { &m.server_streaming },
3654            |m: &mut MethodDescriptorProto| { &mut m.server_streaming },
3655        ));
3656        crate::reflect::GeneratedMessageDescriptorData::new_2::<MethodDescriptorProto>(
3657            "MethodDescriptorProto",
3658            fields,
3659            oneofs,
3660        )
3661    }
3662}
3663
3664impl crate::Message for MethodDescriptorProto {
3665    const NAME: &'static str = "MethodDescriptorProto";
3666
3667    fn is_initialized(&self) -> bool {
3668        for v in &self.options {
3669            if !v.is_initialized() {
3670                return false;
3671            }
3672        };
3673        true
3674    }
3675
3676    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::Result<()> {
3677        while let Some(tag) = is.read_raw_tag_or_eof()? {
3678            match tag {
3679                10 => {
3680                    self.name = ::std::option::Option::Some(is.read_string()?);
3681                },
3682                18 => {
3683                    self.input_type = ::std::option::Option::Some(is.read_string()?);
3684                },
3685                26 => {
3686                    self.output_type = ::std::option::Option::Some(is.read_string()?);
3687                },
3688                34 => {
3689                    crate::rt::read_singular_message_into_field(is, &mut self.options)?;
3690                },
3691                40 => {
3692                    self.client_streaming = ::std::option::Option::Some(is.read_bool()?);
3693                },
3694                48 => {
3695                    self.server_streaming = ::std::option::Option::Some(is.read_bool()?);
3696                },
3697                tag => {
3698                    crate::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
3699                },
3700            };
3701        }
3702        ::std::result::Result::Ok(())
3703    }
3704
3705    // Compute sizes of nested messages
3706    #[allow(unused_variables)]
3707    fn compute_size(&self) -> u64 {
3708        let mut my_size = 0;
3709        if let Some(v) = self.name.as_ref() {
3710            my_size += crate::rt::string_size(1, &v);
3711        }
3712        if let Some(v) = self.input_type.as_ref() {
3713            my_size += crate::rt::string_size(2, &v);
3714        }
3715        if let Some(v) = self.output_type.as_ref() {
3716            my_size += crate::rt::string_size(3, &v);
3717        }
3718        if let Some(v) = self.options.as_ref() {
3719            let len = v.compute_size();
3720            my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len;
3721        }
3722        if let Some(v) = self.client_streaming {
3723            my_size += 1 + 1;
3724        }
3725        if let Some(v) = self.server_streaming {
3726            my_size += 1 + 1;
3727        }
3728        my_size += crate::rt::unknown_fields_size(self.special_fields.unknown_fields());
3729        self.special_fields.cached_size().set(my_size as u32);
3730        my_size
3731    }
3732
3733    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::Result<()> {
3734        if let Some(v) = self.name.as_ref() {
3735            os.write_string(1, v)?;
3736        }
3737        if let Some(v) = self.input_type.as_ref() {
3738            os.write_string(2, v)?;
3739        }
3740        if let Some(v) = self.output_type.as_ref() {
3741            os.write_string(3, v)?;
3742        }
3743        if let Some(v) = self.options.as_ref() {
3744            crate::rt::write_message_field_with_cached_size(4, v, os)?;
3745        }
3746        if let Some(v) = self.client_streaming {
3747            os.write_bool(5, v)?;
3748        }
3749        if let Some(v) = self.server_streaming {
3750            os.write_bool(6, v)?;
3751        }
3752        os.write_unknown_fields(self.special_fields.unknown_fields())?;
3753        ::std::result::Result::Ok(())
3754    }
3755
3756    fn special_fields(&self) -> &crate::SpecialFields {
3757        &self.special_fields
3758    }
3759
3760    fn mut_special_fields(&mut self) -> &mut crate::SpecialFields {
3761        &mut self.special_fields
3762    }
3763
3764    fn new() -> MethodDescriptorProto {
3765        MethodDescriptorProto::new()
3766    }
3767
3768    fn clear(&mut self) {
3769        self.name = ::std::option::Option::None;
3770        self.input_type = ::std::option::Option::None;
3771        self.output_type = ::std::option::Option::None;
3772        self.options.clear();
3773        self.client_streaming = ::std::option::Option::None;
3774        self.server_streaming = ::std::option::Option::None;
3775        self.special_fields.clear();
3776    }
3777
3778    fn default_instance() -> &'static MethodDescriptorProto {
3779        static instance: MethodDescriptorProto = MethodDescriptorProto {
3780            name: ::std::option::Option::None,
3781            input_type: ::std::option::Option::None,
3782            output_type: ::std::option::Option::None,
3783            options: crate::MessageField::none(),
3784            client_streaming: ::std::option::Option::None,
3785            server_streaming: ::std::option::Option::None,
3786            special_fields: crate::SpecialFields::new(),
3787        };
3788        &instance
3789    }
3790}
3791
3792impl crate::MessageFull for MethodDescriptorProto {
3793    fn descriptor() -> crate::reflect::MessageDescriptor {
3794        static descriptor: crate::rt::Lazy<crate::reflect::MessageDescriptor> = crate::rt::Lazy::new();
3795        descriptor.get(|| file_descriptor().message_by_package_relative_name("MethodDescriptorProto").unwrap()).clone()
3796    }
3797}
3798
3799impl ::std::fmt::Display for MethodDescriptorProto {
3800    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3801        crate::text_format::fmt(self, f)
3802    }
3803}
3804
3805impl crate::reflect::ProtobufValue for MethodDescriptorProto {
3806    type RuntimeType = crate::reflect::rt::RuntimeTypeMessage<Self>;
3807}
3808
3809// @@protoc_insertion_point(message:google.protobuf.FileOptions)
3810#[derive(PartialEq,Clone,Default,Debug)]
3811pub struct FileOptions {
3812    // message fields
3813    ///  Sets the Java package where classes generated from this .proto will be
3814    ///  placed.  By default, the proto package is used, but this is often
3815    ///  inappropriate because proto packages do not normally start with backwards
3816    ///  domain names.
3817    // @@protoc_insertion_point(field:google.protobuf.FileOptions.java_package)
3818    pub java_package: ::std::option::Option<::std::string::String>,
3819    ///  Controls the name of the wrapper Java class generated for the .proto file.
3820    ///  That class will always contain the .proto file's getDescriptor() method as
3821    ///  well as any top-level extensions defined in the .proto file.
3822    ///  If java_multiple_files is disabled, then all the other classes from the
3823    ///  .proto file will be nested inside the single wrapper outer class.
3824    // @@protoc_insertion_point(field:google.protobuf.FileOptions.java_outer_classname)
3825    pub java_outer_classname: ::std::option::Option<::std::string::String>,
3826    ///  If enabled, then the Java code generator will generate a separate .java
3827    ///  file for each top-level message, enum, and service defined in the .proto
3828    ///  file.  Thus, these types will *not* be nested inside the wrapper class
3829    ///  named by java_outer_classname.  However, the wrapper class will still be
3830    ///  generated to contain the file's getDescriptor() method as well as any
3831    ///  top-level extensions defined in the file.
3832    // @@protoc_insertion_point(field:google.protobuf.FileOptions.java_multiple_files)
3833    pub java_multiple_files: ::std::option::Option<bool>,
3834    ///  This option does nothing.
3835    // @@protoc_insertion_point(field:google.protobuf.FileOptions.java_generate_equals_and_hash)
3836    pub java_generate_equals_and_hash: ::std::option::Option<bool>,
3837    ///  If set true, then the Java2 code generator will generate code that
3838    ///  throws an exception whenever an attempt is made to assign a non-UTF-8
3839    ///  byte sequence to a string field.
3840    ///  Message reflection will do the same.
3841    ///  However, an extension field still accepts non-UTF-8 byte sequences.
3842    ///  This option has no effect on when used with the lite runtime.
3843    // @@protoc_insertion_point(field:google.protobuf.FileOptions.java_string_check_utf8)
3844    pub java_string_check_utf8: ::std::option::Option<bool>,
3845    // @@protoc_insertion_point(field:google.protobuf.FileOptions.optimize_for)
3846    pub optimize_for: ::std::option::Option<crate::EnumOrUnknown<file_options::OptimizeMode>>,
3847    ///  Sets the Go package where structs generated from this .proto will be
3848    ///  placed. If omitted, the Go package will be derived from the following:
3849    ///    - The basename of the package import path, if provided.
3850    ///    - Otherwise, the package statement in the .proto file, if present.
3851    ///    - Otherwise, the basename of the .proto file, without extension.
3852    // @@protoc_insertion_point(field:google.protobuf.FileOptions.go_package)
3853    pub go_package: ::std::option::Option<::std::string::String>,
3854    ///  Should generic services be generated in each language?  "Generic" services
3855    ///  are not specific to any particular RPC system.  They are generated by the
3856    ///  main code generators in each language (without additional plugins).
3857    ///  Generic services were the only kind of service generation supported by
3858    ///  early versions of google.protobuf.
3859    ///
3860    ///  Generic services are now considered deprecated in favor of using plugins
3861    ///  that generate code specific to your particular RPC system.  Therefore,
3862    ///  these default to false.  Old code which depends on generic services should
3863    ///  explicitly set them to true.
3864    // @@protoc_insertion_point(field:google.protobuf.FileOptions.cc_generic_services)
3865    pub cc_generic_services: ::std::option::Option<bool>,
3866    // @@protoc_insertion_point(field:google.protobuf.FileOptions.java_generic_services)
3867    pub java_generic_services: ::std::option::Option<bool>,
3868    // @@protoc_insertion_point(field:google.protobuf.FileOptions.py_generic_services)
3869    pub py_generic_services: ::std::option::Option<bool>,
3870    // @@protoc_insertion_point(field:google.protobuf.FileOptions.php_generic_services)
3871    pub php_generic_services: ::std::option::Option<bool>,
3872    ///  Is this file deprecated?
3873    ///  Depending on the target platform, this can emit Deprecated annotations
3874    ///  for everything in the file, or it will be completely ignored; in the very
3875    ///  least, this is a formalization for deprecating files.
3876    // @@protoc_insertion_point(field:google.protobuf.FileOptions.deprecated)
3877    pub deprecated: ::std::option::Option<bool>,
3878    ///  Enables the use of arenas for the proto messages in this file. This applies
3879    ///  only to generated classes for C++.
3880    // @@protoc_insertion_point(field:google.protobuf.FileOptions.cc_enable_arenas)
3881    pub cc_enable_arenas: ::std::option::Option<bool>,
3882    ///  Sets the objective c class prefix which is prepended to all objective c
3883    ///  generated classes from this .proto. There is no default.
3884    // @@protoc_insertion_point(field:google.protobuf.FileOptions.objc_class_prefix)
3885    pub objc_class_prefix: ::std::option::Option<::std::string::String>,
3886    ///  Namespace for generated classes; defaults to the package.
3887    // @@protoc_insertion_point(field:google.protobuf.FileOptions.csharp_namespace)
3888    pub csharp_namespace: ::std::option::Option<::std::string::String>,
3889    ///  By default Swift generators will take the proto package and CamelCase it
3890    ///  replacing '.' with underscore and use that to prefix the types/symbols
3891    ///  defined. When this options is provided, they will use this value instead
3892    ///  to prefix the types/symbols defined.
3893    // @@protoc_insertion_point(field:google.protobuf.FileOptions.swift_prefix)
3894    pub swift_prefix: ::std::option::Option<::std::string::String>,
3895    ///  Sets the php class prefix which is prepended to all php generated classes
3896    ///  from this .proto. Default is empty.
3897    // @@protoc_insertion_point(field:google.protobuf.FileOptions.php_class_prefix)
3898    pub php_class_prefix: ::std::option::Option<::std::string::String>,
3899    ///  Use this option to change the namespace of php generated classes. Default
3900    ///  is empty. When this option is empty, the package name will be used for
3901    ///  determining the namespace.
3902    // @@protoc_insertion_point(field:google.protobuf.FileOptions.php_namespace)
3903    pub php_namespace: ::std::option::Option<::std::string::String>,
3904    ///  Use this option to change the namespace of php generated metadata classes.
3905    ///  Default is empty. When this option is empty, the proto file name will be
3906    ///  used for determining the namespace.
3907    // @@protoc_insertion_point(field:google.protobuf.FileOptions.php_metadata_namespace)
3908    pub php_metadata_namespace: ::std::option::Option<::std::string::String>,
3909    ///  Use this option to change the package of ruby generated classes. Default
3910    ///  is empty. When this option is not set, the package name will be used for
3911    ///  determining the ruby package.
3912    // @@protoc_insertion_point(field:google.protobuf.FileOptions.ruby_package)
3913    pub ruby_package: ::std::option::Option<::std::string::String>,
3914    ///  The parser stores options it doesn't recognize here.
3915    ///  See the documentation for the "Options" section above.
3916    // @@protoc_insertion_point(field:google.protobuf.FileOptions.uninterpreted_option)
3917    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
3918    // special fields
3919    // @@protoc_insertion_point(special_field:google.protobuf.FileOptions.special_fields)
3920    pub special_fields: crate::SpecialFields,
3921}
3922
3923impl<'a> ::std::default::Default for &'a FileOptions {
3924    fn default() -> &'a FileOptions {
3925        <FileOptions as crate::Message>::default_instance()
3926    }
3927}
3928
3929impl FileOptions {
3930    pub fn new() -> FileOptions {
3931        ::std::default::Default::default()
3932    }
3933
3934    // optional string java_package = 1;
3935
3936    pub fn java_package(&self) -> &str {
3937        match self.java_package.as_ref() {
3938            Some(v) => v,
3939            None => "",
3940        }
3941    }
3942
3943    pub fn clear_java_package(&mut self) {
3944        self.java_package = ::std::option::Option::None;
3945    }
3946
3947    pub fn has_java_package(&self) -> bool {
3948        self.java_package.is_some()
3949    }
3950
3951    // Param is passed by value, moved
3952    pub fn set_java_package(&mut self, v: ::std::string::String) {
3953        self.java_package = ::std::option::Option::Some(v);
3954    }
3955
3956    // Mutable pointer to the field.
3957    // If field is not initialized, it is initialized with default value first.
3958    pub fn mut_java_package(&mut self) -> &mut ::std::string::String {
3959        if self.java_package.is_none() {
3960            self.java_package = ::std::option::Option::Some(::std::string::String::new());
3961        }
3962        self.java_package.as_mut().unwrap()
3963    }
3964
3965    // Take field
3966    pub fn take_java_package(&mut self) -> ::std::string::String {
3967        self.java_package.take().unwrap_or_else(|| ::std::string::String::new())
3968    }
3969
3970    // optional string java_outer_classname = 8;
3971
3972    pub fn java_outer_classname(&self) -> &str {
3973        match self.java_outer_classname.as_ref() {
3974            Some(v) => v,
3975            None => "",
3976        }
3977    }
3978
3979    pub fn clear_java_outer_classname(&mut self) {
3980        self.java_outer_classname = ::std::option::Option::None;
3981    }
3982
3983    pub fn has_java_outer_classname(&self) -> bool {
3984        self.java_outer_classname.is_some()
3985    }
3986
3987    // Param is passed by value, moved
3988    pub fn set_java_outer_classname(&mut self, v: ::std::string::String) {
3989        self.java_outer_classname = ::std::option::Option::Some(v);
3990    }
3991
3992    // Mutable pointer to the field.
3993    // If field is not initialized, it is initialized with default value first.
3994    pub fn mut_java_outer_classname(&mut self) -> &mut ::std::string::String {
3995        if self.java_outer_classname.is_none() {
3996            self.java_outer_classname = ::std::option::Option::Some(::std::string::String::new());
3997        }
3998        self.java_outer_classname.as_mut().unwrap()
3999    }
4000
4001    // Take field
4002    pub fn take_java_outer_classname(&mut self) -> ::std::string::String {
4003        self.java_outer_classname.take().unwrap_or_else(|| ::std::string::String::new())
4004    }
4005
4006    // optional bool java_multiple_files = 10;
4007
4008    pub fn java_multiple_files(&self) -> bool {
4009        self.java_multiple_files.unwrap_or(false)
4010    }
4011
4012    pub fn clear_java_multiple_files(&mut self) {
4013        self.java_multiple_files = ::std::option::Option::None;
4014    }
4015
4016    pub fn has_java_multiple_files(&self) -> bool {
4017        self.java_multiple_files.is_some()
4018    }
4019
4020    // Param is passed by value, moved
4021    pub fn set_java_multiple_files(&mut self, v: bool) {
4022        self.java_multiple_files = ::std::option::Option::Some(v);
4023    }
4024
4025    // optional bool java_generate_equals_and_hash = 20;
4026
4027    pub fn java_generate_equals_and_hash(&self) -> bool {
4028        self.java_generate_equals_and_hash.unwrap_or(false)
4029    }
4030
4031    pub fn clear_java_generate_equals_and_hash(&mut self) {
4032        self.java_generate_equals_and_hash = ::std::option::Option::None;
4033    }
4034
4035    pub fn has_java_generate_equals_and_hash(&self) -> bool {
4036        self.java_generate_equals_and_hash.is_some()
4037    }
4038
4039    // Param is passed by value, moved
4040    pub fn set_java_generate_equals_and_hash(&mut self, v: bool) {
4041        self.java_generate_equals_and_hash = ::std::option::Option::Some(v);
4042    }
4043
4044    // optional bool java_string_check_utf8 = 27;
4045
4046    pub fn java_string_check_utf8(&self) -> bool {
4047        self.java_string_check_utf8.unwrap_or(false)
4048    }
4049
4050    pub fn clear_java_string_check_utf8(&mut self) {
4051        self.java_string_check_utf8 = ::std::option::Option::None;
4052    }
4053
4054    pub fn has_java_string_check_utf8(&self) -> bool {
4055        self.java_string_check_utf8.is_some()
4056    }
4057
4058    // Param is passed by value, moved
4059    pub fn set_java_string_check_utf8(&mut self, v: bool) {
4060        self.java_string_check_utf8 = ::std::option::Option::Some(v);
4061    }
4062
4063    // optional .google.protobuf.FileOptions.OptimizeMode optimize_for = 9;
4064
4065    pub fn optimize_for(&self) -> file_options::OptimizeMode {
4066        match self.optimize_for {
4067            Some(e) => e.enum_value_or(file_options::OptimizeMode::SPEED),
4068            None => file_options::OptimizeMode::SPEED,
4069        }
4070    }
4071
4072    pub fn clear_optimize_for(&mut self) {
4073        self.optimize_for = ::std::option::Option::None;
4074    }
4075
4076    pub fn has_optimize_for(&self) -> bool {
4077        self.optimize_for.is_some()
4078    }
4079
4080    // Param is passed by value, moved
4081    pub fn set_optimize_for(&mut self, v: file_options::OptimizeMode) {
4082        self.optimize_for = ::std::option::Option::Some(crate::EnumOrUnknown::new(v));
4083    }
4084
4085    // optional string go_package = 11;
4086
4087    pub fn go_package(&self) -> &str {
4088        match self.go_package.as_ref() {
4089            Some(v) => v,
4090            None => "",
4091        }
4092    }
4093
4094    pub fn clear_go_package(&mut self) {
4095        self.go_package = ::std::option::Option::None;
4096    }
4097
4098    pub fn has_go_package(&self) -> bool {
4099        self.go_package.is_some()
4100    }
4101
4102    // Param is passed by value, moved
4103    pub fn set_go_package(&mut self, v: ::std::string::String) {
4104        self.go_package = ::std::option::Option::Some(v);
4105    }
4106
4107    // Mutable pointer to the field.
4108    // If field is not initialized, it is initialized with default value first.
4109    pub fn mut_go_package(&mut self) -> &mut ::std::string::String {
4110        if self.go_package.is_none() {
4111            self.go_package = ::std::option::Option::Some(::std::string::String::new());
4112        }
4113        self.go_package.as_mut().unwrap()
4114    }
4115
4116    // Take field
4117    pub fn take_go_package(&mut self) -> ::std::string::String {
4118        self.go_package.take().unwrap_or_else(|| ::std::string::String::new())
4119    }
4120
4121    // optional bool cc_generic_services = 16;
4122
4123    pub fn cc_generic_services(&self) -> bool {
4124        self.cc_generic_services.unwrap_or(false)
4125    }
4126
4127    pub fn clear_cc_generic_services(&mut self) {
4128        self.cc_generic_services = ::std::option::Option::None;
4129    }
4130
4131    pub fn has_cc_generic_services(&self) -> bool {
4132        self.cc_generic_services.is_some()
4133    }
4134
4135    // Param is passed by value, moved
4136    pub fn set_cc_generic_services(&mut self, v: bool) {
4137        self.cc_generic_services = ::std::option::Option::Some(v);
4138    }
4139
4140    // optional bool java_generic_services = 17;
4141
4142    pub fn java_generic_services(&self) -> bool {
4143        self.java_generic_services.unwrap_or(false)
4144    }
4145
4146    pub fn clear_java_generic_services(&mut self) {
4147        self.java_generic_services = ::std::option::Option::None;
4148    }
4149
4150    pub fn has_java_generic_services(&self) -> bool {
4151        self.java_generic_services.is_some()
4152    }
4153
4154    // Param is passed by value, moved
4155    pub fn set_java_generic_services(&mut self, v: bool) {
4156        self.java_generic_services = ::std::option::Option::Some(v);
4157    }
4158
4159    // optional bool py_generic_services = 18;
4160
4161    pub fn py_generic_services(&self) -> bool {
4162        self.py_generic_services.unwrap_or(false)
4163    }
4164
4165    pub fn clear_py_generic_services(&mut self) {
4166        self.py_generic_services = ::std::option::Option::None;
4167    }
4168
4169    pub fn has_py_generic_services(&self) -> bool {
4170        self.py_generic_services.is_some()
4171    }
4172
4173    // Param is passed by value, moved
4174    pub fn set_py_generic_services(&mut self, v: bool) {
4175        self.py_generic_services = ::std::option::Option::Some(v);
4176    }
4177
4178    // optional bool php_generic_services = 42;
4179
4180    pub fn php_generic_services(&self) -> bool {
4181        self.php_generic_services.unwrap_or(false)
4182    }
4183
4184    pub fn clear_php_generic_services(&mut self) {
4185        self.php_generic_services = ::std::option::Option::None;
4186    }
4187
4188    pub fn has_php_generic_services(&self) -> bool {
4189        self.php_generic_services.is_some()
4190    }
4191
4192    // Param is passed by value, moved
4193    pub fn set_php_generic_services(&mut self, v: bool) {
4194        self.php_generic_services = ::std::option::Option::Some(v);
4195    }
4196
4197    // optional bool deprecated = 23;
4198
4199    pub fn deprecated(&self) -> bool {
4200        self.deprecated.unwrap_or(false)
4201    }
4202
4203    pub fn clear_deprecated(&mut self) {
4204        self.deprecated = ::std::option::Option::None;
4205    }
4206
4207    pub fn has_deprecated(&self) -> bool {
4208        self.deprecated.is_some()
4209    }
4210
4211    // Param is passed by value, moved
4212    pub fn set_deprecated(&mut self, v: bool) {
4213        self.deprecated = ::std::option::Option::Some(v);
4214    }
4215
4216    // optional bool cc_enable_arenas = 31;
4217
4218    pub fn cc_enable_arenas(&self) -> bool {
4219        self.cc_enable_arenas.unwrap_or(true)
4220    }
4221
4222    pub fn clear_cc_enable_arenas(&mut self) {
4223        self.cc_enable_arenas = ::std::option::Option::None;
4224    }
4225
4226    pub fn has_cc_enable_arenas(&self) -> bool {
4227        self.cc_enable_arenas.is_some()
4228    }
4229
4230    // Param is passed by value, moved
4231    pub fn set_cc_enable_arenas(&mut self, v: bool) {
4232        self.cc_enable_arenas = ::std::option::Option::Some(v);
4233    }
4234
4235    // optional string objc_class_prefix = 36;
4236
4237    pub fn objc_class_prefix(&self) -> &str {
4238        match self.objc_class_prefix.as_ref() {
4239            Some(v) => v,
4240            None => "",
4241        }
4242    }
4243
4244    pub fn clear_objc_class_prefix(&mut self) {
4245        self.objc_class_prefix = ::std::option::Option::None;
4246    }
4247
4248    pub fn has_objc_class_prefix(&self) -> bool {
4249        self.objc_class_prefix.is_some()
4250    }
4251
4252    // Param is passed by value, moved
4253    pub fn set_objc_class_prefix(&mut self, v: ::std::string::String) {
4254        self.objc_class_prefix = ::std::option::Option::Some(v);
4255    }
4256
4257    // Mutable pointer to the field.
4258    // If field is not initialized, it is initialized with default value first.
4259    pub fn mut_objc_class_prefix(&mut self) -> &mut ::std::string::String {
4260        if self.objc_class_prefix.is_none() {
4261            self.objc_class_prefix = ::std::option::Option::Some(::std::string::String::new());
4262        }
4263        self.objc_class_prefix.as_mut().unwrap()
4264    }
4265
4266    // Take field
4267    pub fn take_objc_class_prefix(&mut self) -> ::std::string::String {
4268        self.objc_class_prefix.take().unwrap_or_else(|| ::std::string::String::new())
4269    }
4270
4271    // optional string csharp_namespace = 37;
4272
4273    pub fn csharp_namespace(&self) -> &str {
4274        match self.csharp_namespace.as_ref() {
4275            Some(v) => v,
4276            None => "",
4277        }
4278    }
4279
4280    pub fn clear_csharp_namespace(&mut self) {
4281        self.csharp_namespace = ::std::option::Option::None;
4282    }
4283
4284    pub fn has_csharp_namespace(&self) -> bool {
4285        self.csharp_namespace.is_some()
4286    }
4287
4288    // Param is passed by value, moved
4289    pub fn set_csharp_namespace(&mut self, v: ::std::string::String) {
4290        self.csharp_namespace = ::std::option::Option::Some(v);
4291    }
4292
4293    // Mutable pointer to the field.
4294    // If field is not initialized, it is initialized with default value first.
4295    pub fn mut_csharp_namespace(&mut self) -> &mut ::std::string::String {
4296        if self.csharp_namespace.is_none() {
4297            self.csharp_namespace = ::std::option::Option::Some(::std::string::String::new());
4298        }
4299        self.csharp_namespace.as_mut().unwrap()
4300    }
4301
4302    // Take field
4303    pub fn take_csharp_namespace(&mut self) -> ::std::string::String {
4304        self.csharp_namespace.take().unwrap_or_else(|| ::std::string::String::new())
4305    }
4306
4307    // optional string swift_prefix = 39;
4308
4309    pub fn swift_prefix(&self) -> &str {
4310        match self.swift_prefix.as_ref() {
4311            Some(v) => v,
4312            None => "",
4313        }
4314    }
4315
4316    pub fn clear_swift_prefix(&mut self) {
4317        self.swift_prefix = ::std::option::Option::None;
4318    }
4319
4320    pub fn has_swift_prefix(&self) -> bool {
4321        self.swift_prefix.is_some()
4322    }
4323
4324    // Param is passed by value, moved
4325    pub fn set_swift_prefix(&mut self, v: ::std::string::String) {
4326        self.swift_prefix = ::std::option::Option::Some(v);
4327    }
4328
4329    // Mutable pointer to the field.
4330    // If field is not initialized, it is initialized with default value first.
4331    pub fn mut_swift_prefix(&mut self) -> &mut ::std::string::String {
4332        if self.swift_prefix.is_none() {
4333            self.swift_prefix = ::std::option::Option::Some(::std::string::String::new());
4334        }
4335        self.swift_prefix.as_mut().unwrap()
4336    }
4337
4338    // Take field
4339    pub fn take_swift_prefix(&mut self) -> ::std::string::String {
4340        self.swift_prefix.take().unwrap_or_else(|| ::std::string::String::new())
4341    }
4342
4343    // optional string php_class_prefix = 40;
4344
4345    pub fn php_class_prefix(&self) -> &str {
4346        match self.php_class_prefix.as_ref() {
4347            Some(v) => v,
4348            None => "",
4349        }
4350    }
4351
4352    pub fn clear_php_class_prefix(&mut self) {
4353        self.php_class_prefix = ::std::option::Option::None;
4354    }
4355
4356    pub fn has_php_class_prefix(&self) -> bool {
4357        self.php_class_prefix.is_some()
4358    }
4359
4360    // Param is passed by value, moved
4361    pub fn set_php_class_prefix(&mut self, v: ::std::string::String) {
4362        self.php_class_prefix = ::std::option::Option::Some(v);
4363    }
4364
4365    // Mutable pointer to the field.
4366    // If field is not initialized, it is initialized with default value first.
4367    pub fn mut_php_class_prefix(&mut self) -> &mut ::std::string::String {
4368        if self.php_class_prefix.is_none() {
4369            self.php_class_prefix = ::std::option::Option::Some(::std::string::String::new());
4370        }
4371        self.php_class_prefix.as_mut().unwrap()
4372    }
4373
4374    // Take field
4375    pub fn take_php_class_prefix(&mut self) -> ::std::string::String {
4376        self.php_class_prefix.take().unwrap_or_else(|| ::std::string::String::new())
4377    }
4378
4379    // optional string php_namespace = 41;
4380
4381    pub fn php_namespace(&self) -> &str {
4382        match self.php_namespace.as_ref() {
4383            Some(v) => v,
4384            None => "",
4385        }
4386    }
4387
4388    pub fn clear_php_namespace(&mut self) {
4389        self.php_namespace = ::std::option::Option::None;
4390    }
4391
4392    pub fn has_php_namespace(&self) -> bool {
4393        self.php_namespace.is_some()
4394    }
4395
4396    // Param is passed by value, moved
4397    pub fn set_php_namespace(&mut self, v: ::std::string::String) {
4398        self.php_namespace = ::std::option::Option::Some(v);
4399    }
4400
4401    // Mutable pointer to the field.
4402    // If field is not initialized, it is initialized with default value first.
4403    pub fn mut_php_namespace(&mut self) -> &mut ::std::string::String {
4404        if self.php_namespace.is_none() {
4405            self.php_namespace = ::std::option::Option::Some(::std::string::String::new());
4406        }
4407        self.php_namespace.as_mut().unwrap()
4408    }
4409
4410    // Take field
4411    pub fn take_php_namespace(&mut self) -> ::std::string::String {
4412        self.php_namespace.take().unwrap_or_else(|| ::std::string::String::new())
4413    }
4414
4415    // optional string php_metadata_namespace = 44;
4416
4417    pub fn php_metadata_namespace(&self) -> &str {
4418        match self.php_metadata_namespace.as_ref() {
4419            Some(v) => v,
4420            None => "",
4421        }
4422    }
4423
4424    pub fn clear_php_metadata_namespace(&mut self) {
4425        self.php_metadata_namespace = ::std::option::Option::None;
4426    }
4427
4428    pub fn has_php_metadata_namespace(&self) -> bool {
4429        self.php_metadata_namespace.is_some()
4430    }
4431
4432    // Param is passed by value, moved
4433    pub fn set_php_metadata_namespace(&mut self, v: ::std::string::String) {
4434        self.php_metadata_namespace = ::std::option::Option::Some(v);
4435    }
4436
4437    // Mutable pointer to the field.
4438    // If field is not initialized, it is initialized with default value first.
4439    pub fn mut_php_metadata_namespace(&mut self) -> &mut ::std::string::String {
4440        if self.php_metadata_namespace.is_none() {
4441            self.php_metadata_namespace = ::std::option::Option::Some(::std::string::String::new());
4442        }
4443        self.php_metadata_namespace.as_mut().unwrap()
4444    }
4445
4446    // Take field
4447    pub fn take_php_metadata_namespace(&mut self) -> ::std::string::String {
4448        self.php_metadata_namespace.take().unwrap_or_else(|| ::std::string::String::new())
4449    }
4450
4451    // optional string ruby_package = 45;
4452
4453    pub fn ruby_package(&self) -> &str {
4454        match self.ruby_package.as_ref() {
4455            Some(v) => v,
4456            None => "",
4457        }
4458    }
4459
4460    pub fn clear_ruby_package(&mut self) {
4461        self.ruby_package = ::std::option::Option::None;
4462    }
4463
4464    pub fn has_ruby_package(&self) -> bool {
4465        self.ruby_package.is_some()
4466    }
4467
4468    // Param is passed by value, moved
4469    pub fn set_ruby_package(&mut self, v: ::std::string::String) {
4470        self.ruby_package = ::std::option::Option::Some(v);
4471    }
4472
4473    // Mutable pointer to the field.
4474    // If field is not initialized, it is initialized with default value first.
4475    pub fn mut_ruby_package(&mut self) -> &mut ::std::string::String {
4476        if self.ruby_package.is_none() {
4477            self.ruby_package = ::std::option::Option::Some(::std::string::String::new());
4478        }
4479        self.ruby_package.as_mut().unwrap()
4480    }
4481
4482    // Take field
4483    pub fn take_ruby_package(&mut self) -> ::std::string::String {
4484        self.ruby_package.take().unwrap_or_else(|| ::std::string::String::new())
4485    }
4486
4487    fn generated_message_descriptor_data() -> crate::reflect::GeneratedMessageDescriptorData {
4488        let mut fields = ::std::vec::Vec::with_capacity(21);
4489        let mut oneofs = ::std::vec::Vec::with_capacity(0);
4490        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
4491            "java_package",
4492            |m: &FileOptions| { &m.java_package },
4493            |m: &mut FileOptions| { &mut m.java_package },
4494        ));
4495        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
4496            "java_outer_classname",
4497            |m: &FileOptions| { &m.java_outer_classname },
4498            |m: &mut FileOptions| { &mut m.java_outer_classname },
4499        ));
4500        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
4501            "java_multiple_files",
4502            |m: &FileOptions| { &m.java_multiple_files },
4503            |m: &mut FileOptions| { &mut m.java_multiple_files },
4504        ));
4505        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
4506            "java_generate_equals_and_hash",
4507            |m: &FileOptions| { &m.java_generate_equals_and_hash },
4508            |m: &mut FileOptions| { &mut m.java_generate_equals_and_hash },
4509        ));
4510        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
4511            "java_string_check_utf8",
4512            |m: &FileOptions| { &m.java_string_check_utf8 },
4513            |m: &mut FileOptions| { &mut m.java_string_check_utf8 },
4514        ));
4515        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
4516            "optimize_for",
4517            |m: &FileOptions| { &m.optimize_for },
4518            |m: &mut FileOptions| { &mut m.optimize_for },
4519        ));
4520        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
4521            "go_package",
4522            |m: &FileOptions| { &m.go_package },
4523            |m: &mut FileOptions| { &mut m.go_package },
4524        ));
4525        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
4526            "cc_generic_services",
4527            |m: &FileOptions| { &m.cc_generic_services },
4528            |m: &mut FileOptions| { &mut m.cc_generic_services },
4529        ));
4530        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
4531            "java_generic_services",
4532            |m: &FileOptions| { &m.java_generic_services },
4533            |m: &mut FileOptions| { &mut m.java_generic_services },
4534        ));
4535        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
4536            "py_generic_services",
4537            |m: &FileOptions| { &m.py_generic_services },
4538            |m: &mut FileOptions| { &mut m.py_generic_services },
4539        ));
4540        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
4541            "php_generic_services",
4542            |m: &FileOptions| { &m.php_generic_services },
4543            |m: &mut FileOptions| { &mut m.php_generic_services },
4544        ));
4545        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
4546            "deprecated",
4547            |m: &FileOptions| { &m.deprecated },
4548            |m: &mut FileOptions| { &mut m.deprecated },
4549        ));
4550        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
4551            "cc_enable_arenas",
4552            |m: &FileOptions| { &m.cc_enable_arenas },
4553            |m: &mut FileOptions| { &mut m.cc_enable_arenas },
4554        ));
4555        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
4556            "objc_class_prefix",
4557            |m: &FileOptions| { &m.objc_class_prefix },
4558            |m: &mut FileOptions| { &mut m.objc_class_prefix },
4559        ));
4560        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
4561            "csharp_namespace",
4562            |m: &FileOptions| { &m.csharp_namespace },
4563            |m: &mut FileOptions| { &mut m.csharp_namespace },
4564        ));
4565        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
4566            "swift_prefix",
4567            |m: &FileOptions| { &m.swift_prefix },
4568            |m: &mut FileOptions| { &mut m.swift_prefix },
4569        ));
4570        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
4571            "php_class_prefix",
4572            |m: &FileOptions| { &m.php_class_prefix },
4573            |m: &mut FileOptions| { &mut m.php_class_prefix },
4574        ));
4575        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
4576            "php_namespace",
4577            |m: &FileOptions| { &m.php_namespace },
4578            |m: &mut FileOptions| { &mut m.php_namespace },
4579        ));
4580        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
4581            "php_metadata_namespace",
4582            |m: &FileOptions| { &m.php_metadata_namespace },
4583            |m: &mut FileOptions| { &mut m.php_metadata_namespace },
4584        ));
4585        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
4586            "ruby_package",
4587            |m: &FileOptions| { &m.ruby_package },
4588            |m: &mut FileOptions| { &mut m.ruby_package },
4589        ));
4590        fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
4591            "uninterpreted_option",
4592            |m: &FileOptions| { &m.uninterpreted_option },
4593            |m: &mut FileOptions| { &mut m.uninterpreted_option },
4594        ));
4595        crate::reflect::GeneratedMessageDescriptorData::new_2::<FileOptions>(
4596            "FileOptions",
4597            fields,
4598            oneofs,
4599        )
4600    }
4601}
4602
4603impl crate::Message for FileOptions {
4604    const NAME: &'static str = "FileOptions";
4605
4606    fn is_initialized(&self) -> bool {
4607        for v in &self.uninterpreted_option {
4608            if !v.is_initialized() {
4609                return false;
4610            }
4611        };
4612        true
4613    }
4614
4615    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::Result<()> {
4616        while let Some(tag) = is.read_raw_tag_or_eof()? {
4617            match tag {
4618                10 => {
4619                    self.java_package = ::std::option::Option::Some(is.read_string()?);
4620                },
4621                66 => {
4622                    self.java_outer_classname = ::std::option::Option::Some(is.read_string()?);
4623                },
4624                80 => {
4625                    self.java_multiple_files = ::std::option::Option::Some(is.read_bool()?);
4626                },
4627                160 => {
4628                    self.java_generate_equals_and_hash = ::std::option::Option::Some(is.read_bool()?);
4629                },
4630                216 => {
4631                    self.java_string_check_utf8 = ::std::option::Option::Some(is.read_bool()?);
4632                },
4633                72 => {
4634                    self.optimize_for = ::std::option::Option::Some(is.read_enum_or_unknown()?);
4635                },
4636                90 => {
4637                    self.go_package = ::std::option::Option::Some(is.read_string()?);
4638                },
4639                128 => {
4640                    self.cc_generic_services = ::std::option::Option::Some(is.read_bool()?);
4641                },
4642                136 => {
4643                    self.java_generic_services = ::std::option::Option::Some(is.read_bool()?);
4644                },
4645                144 => {
4646                    self.py_generic_services = ::std::option::Option::Some(is.read_bool()?);
4647                },
4648                336 => {
4649                    self.php_generic_services = ::std::option::Option::Some(is.read_bool()?);
4650                },
4651                184 => {
4652                    self.deprecated = ::std::option::Option::Some(is.read_bool()?);
4653                },
4654                248 => {
4655                    self.cc_enable_arenas = ::std::option::Option::Some(is.read_bool()?);
4656                },
4657                290 => {
4658                    self.objc_class_prefix = ::std::option::Option::Some(is.read_string()?);
4659                },
4660                298 => {
4661                    self.csharp_namespace = ::std::option::Option::Some(is.read_string()?);
4662                },
4663                314 => {
4664                    self.swift_prefix = ::std::option::Option::Some(is.read_string()?);
4665                },
4666                322 => {
4667                    self.php_class_prefix = ::std::option::Option::Some(is.read_string()?);
4668                },
4669                330 => {
4670                    self.php_namespace = ::std::option::Option::Some(is.read_string()?);
4671                },
4672                354 => {
4673                    self.php_metadata_namespace = ::std::option::Option::Some(is.read_string()?);
4674                },
4675                362 => {
4676                    self.ruby_package = ::std::option::Option::Some(is.read_string()?);
4677                },
4678                7994 => {
4679                    self.uninterpreted_option.push(is.read_message()?);
4680                },
4681                tag => {
4682                    crate::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
4683                },
4684            };
4685        }
4686        ::std::result::Result::Ok(())
4687    }
4688
4689    // Compute sizes of nested messages
4690    #[allow(unused_variables)]
4691    fn compute_size(&self) -> u64 {
4692        let mut my_size = 0;
4693        if let Some(v) = self.java_package.as_ref() {
4694            my_size += crate::rt::string_size(1, &v);
4695        }
4696        if let Some(v) = self.java_outer_classname.as_ref() {
4697            my_size += crate::rt::string_size(8, &v);
4698        }
4699        if let Some(v) = self.java_multiple_files {
4700            my_size += 1 + 1;
4701        }
4702        if let Some(v) = self.java_generate_equals_and_hash {
4703            my_size += 2 + 1;
4704        }
4705        if let Some(v) = self.java_string_check_utf8 {
4706            my_size += 2 + 1;
4707        }
4708        if let Some(v) = self.optimize_for {
4709            my_size += crate::rt::int32_size(9, v.value());
4710        }
4711        if let Some(v) = self.go_package.as_ref() {
4712            my_size += crate::rt::string_size(11, &v);
4713        }
4714        if let Some(v) = self.cc_generic_services {
4715            my_size += 2 + 1;
4716        }
4717        if let Some(v) = self.java_generic_services {
4718            my_size += 2 + 1;
4719        }
4720        if let Some(v) = self.py_generic_services {
4721            my_size += 2 + 1;
4722        }
4723        if let Some(v) = self.php_generic_services {
4724            my_size += 2 + 1;
4725        }
4726        if let Some(v) = self.deprecated {
4727            my_size += 2 + 1;
4728        }
4729        if let Some(v) = self.cc_enable_arenas {
4730            my_size += 2 + 1;
4731        }
4732        if let Some(v) = self.objc_class_prefix.as_ref() {
4733            my_size += crate::rt::string_size(36, &v);
4734        }
4735        if let Some(v) = self.csharp_namespace.as_ref() {
4736            my_size += crate::rt::string_size(37, &v);
4737        }
4738        if let Some(v) = self.swift_prefix.as_ref() {
4739            my_size += crate::rt::string_size(39, &v);
4740        }
4741        if let Some(v) = self.php_class_prefix.as_ref() {
4742            my_size += crate::rt::string_size(40, &v);
4743        }
4744        if let Some(v) = self.php_namespace.as_ref() {
4745            my_size += crate::rt::string_size(41, &v);
4746        }
4747        if let Some(v) = self.php_metadata_namespace.as_ref() {
4748            my_size += crate::rt::string_size(44, &v);
4749        }
4750        if let Some(v) = self.ruby_package.as_ref() {
4751            my_size += crate::rt::string_size(45, &v);
4752        }
4753        for value in &self.uninterpreted_option {
4754            let len = value.compute_size();
4755            my_size += 2 + crate::rt::compute_raw_varint64_size(len) + len;
4756        };
4757        my_size += crate::rt::unknown_fields_size(self.special_fields.unknown_fields());
4758        self.special_fields.cached_size().set(my_size as u32);
4759        my_size
4760    }
4761
4762    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::Result<()> {
4763        if let Some(v) = self.java_package.as_ref() {
4764            os.write_string(1, v)?;
4765        }
4766        if let Some(v) = self.java_outer_classname.as_ref() {
4767            os.write_string(8, v)?;
4768        }
4769        if let Some(v) = self.java_multiple_files {
4770            os.write_bool(10, v)?;
4771        }
4772        if let Some(v) = self.java_generate_equals_and_hash {
4773            os.write_bool(20, v)?;
4774        }
4775        if let Some(v) = self.java_string_check_utf8 {
4776            os.write_bool(27, v)?;
4777        }
4778        if let Some(v) = self.optimize_for {
4779            os.write_enum(9, crate::EnumOrUnknown::value(&v))?;
4780        }
4781        if let Some(v) = self.go_package.as_ref() {
4782            os.write_string(11, v)?;
4783        }
4784        if let Some(v) = self.cc_generic_services {
4785            os.write_bool(16, v)?;
4786        }
4787        if let Some(v) = self.java_generic_services {
4788            os.write_bool(17, v)?;
4789        }
4790        if let Some(v) = self.py_generic_services {
4791            os.write_bool(18, v)?;
4792        }
4793        if let Some(v) = self.php_generic_services {
4794            os.write_bool(42, v)?;
4795        }
4796        if let Some(v) = self.deprecated {
4797            os.write_bool(23, v)?;
4798        }
4799        if let Some(v) = self.cc_enable_arenas {
4800            os.write_bool(31, v)?;
4801        }
4802        if let Some(v) = self.objc_class_prefix.as_ref() {
4803            os.write_string(36, v)?;
4804        }
4805        if let Some(v) = self.csharp_namespace.as_ref() {
4806            os.write_string(37, v)?;
4807        }
4808        if let Some(v) = self.swift_prefix.as_ref() {
4809            os.write_string(39, v)?;
4810        }
4811        if let Some(v) = self.php_class_prefix.as_ref() {
4812            os.write_string(40, v)?;
4813        }
4814        if let Some(v) = self.php_namespace.as_ref() {
4815            os.write_string(41, v)?;
4816        }
4817        if let Some(v) = self.php_metadata_namespace.as_ref() {
4818            os.write_string(44, v)?;
4819        }
4820        if let Some(v) = self.ruby_package.as_ref() {
4821            os.write_string(45, v)?;
4822        }
4823        for v in &self.uninterpreted_option {
4824            crate::rt::write_message_field_with_cached_size(999, v, os)?;
4825        };
4826        os.write_unknown_fields(self.special_fields.unknown_fields())?;
4827        ::std::result::Result::Ok(())
4828    }
4829
4830    fn special_fields(&self) -> &crate::SpecialFields {
4831        &self.special_fields
4832    }
4833
4834    fn mut_special_fields(&mut self) -> &mut crate::SpecialFields {
4835        &mut self.special_fields
4836    }
4837
4838    fn new() -> FileOptions {
4839        FileOptions::new()
4840    }
4841
4842    fn clear(&mut self) {
4843        self.java_package = ::std::option::Option::None;
4844        self.java_outer_classname = ::std::option::Option::None;
4845        self.java_multiple_files = ::std::option::Option::None;
4846        self.java_generate_equals_and_hash = ::std::option::Option::None;
4847        self.java_string_check_utf8 = ::std::option::Option::None;
4848        self.optimize_for = ::std::option::Option::None;
4849        self.go_package = ::std::option::Option::None;
4850        self.cc_generic_services = ::std::option::Option::None;
4851        self.java_generic_services = ::std::option::Option::None;
4852        self.py_generic_services = ::std::option::Option::None;
4853        self.php_generic_services = ::std::option::Option::None;
4854        self.deprecated = ::std::option::Option::None;
4855        self.cc_enable_arenas = ::std::option::Option::None;
4856        self.objc_class_prefix = ::std::option::Option::None;
4857        self.csharp_namespace = ::std::option::Option::None;
4858        self.swift_prefix = ::std::option::Option::None;
4859        self.php_class_prefix = ::std::option::Option::None;
4860        self.php_namespace = ::std::option::Option::None;
4861        self.php_metadata_namespace = ::std::option::Option::None;
4862        self.ruby_package = ::std::option::Option::None;
4863        self.uninterpreted_option.clear();
4864        self.special_fields.clear();
4865    }
4866
4867    fn default_instance() -> &'static FileOptions {
4868        static instance: FileOptions = FileOptions {
4869            java_package: ::std::option::Option::None,
4870            java_outer_classname: ::std::option::Option::None,
4871            java_multiple_files: ::std::option::Option::None,
4872            java_generate_equals_and_hash: ::std::option::Option::None,
4873            java_string_check_utf8: ::std::option::Option::None,
4874            optimize_for: ::std::option::Option::None,
4875            go_package: ::std::option::Option::None,
4876            cc_generic_services: ::std::option::Option::None,
4877            java_generic_services: ::std::option::Option::None,
4878            py_generic_services: ::std::option::Option::None,
4879            php_generic_services: ::std::option::Option::None,
4880            deprecated: ::std::option::Option::None,
4881            cc_enable_arenas: ::std::option::Option::None,
4882            objc_class_prefix: ::std::option::Option::None,
4883            csharp_namespace: ::std::option::Option::None,
4884            swift_prefix: ::std::option::Option::None,
4885            php_class_prefix: ::std::option::Option::None,
4886            php_namespace: ::std::option::Option::None,
4887            php_metadata_namespace: ::std::option::Option::None,
4888            ruby_package: ::std::option::Option::None,
4889            uninterpreted_option: ::std::vec::Vec::new(),
4890            special_fields: crate::SpecialFields::new(),
4891        };
4892        &instance
4893    }
4894}
4895
4896impl crate::MessageFull for FileOptions {
4897    fn descriptor() -> crate::reflect::MessageDescriptor {
4898        static descriptor: crate::rt::Lazy<crate::reflect::MessageDescriptor> = crate::rt::Lazy::new();
4899        descriptor.get(|| file_descriptor().message_by_package_relative_name("FileOptions").unwrap()).clone()
4900    }
4901}
4902
4903impl ::std::fmt::Display for FileOptions {
4904    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4905        crate::text_format::fmt(self, f)
4906    }
4907}
4908
4909impl crate::reflect::ProtobufValue for FileOptions {
4910    type RuntimeType = crate::reflect::rt::RuntimeTypeMessage<Self>;
4911}
4912
4913/// Nested message and enums of message `FileOptions`
4914pub mod file_options {
4915    ///  Generated classes can be optimized for speed or code size.
4916    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
4917    // @@protoc_insertion_point(enum:google.protobuf.FileOptions.OptimizeMode)
4918    pub enum OptimizeMode {
4919        // @@protoc_insertion_point(enum_value:google.protobuf.FileOptions.OptimizeMode.SPEED)
4920        SPEED = 1,
4921        // @@protoc_insertion_point(enum_value:google.protobuf.FileOptions.OptimizeMode.CODE_SIZE)
4922        CODE_SIZE = 2,
4923        // @@protoc_insertion_point(enum_value:google.protobuf.FileOptions.OptimizeMode.LITE_RUNTIME)
4924        LITE_RUNTIME = 3,
4925    }
4926
4927    impl crate::Enum for OptimizeMode {
4928        const NAME: &'static str = "OptimizeMode";
4929
4930        fn value(&self) -> i32 {
4931            *self as i32
4932        }
4933
4934        fn from_i32(value: i32) -> ::std::option::Option<OptimizeMode> {
4935            match value {
4936                1 => ::std::option::Option::Some(OptimizeMode::SPEED),
4937                2 => ::std::option::Option::Some(OptimizeMode::CODE_SIZE),
4938                3 => ::std::option::Option::Some(OptimizeMode::LITE_RUNTIME),
4939                _ => ::std::option::Option::None
4940            }
4941        }
4942
4943        fn from_str(str: &str) -> ::std::option::Option<OptimizeMode> {
4944            match str {
4945                "SPEED" => ::std::option::Option::Some(OptimizeMode::SPEED),
4946                "CODE_SIZE" => ::std::option::Option::Some(OptimizeMode::CODE_SIZE),
4947                "LITE_RUNTIME" => ::std::option::Option::Some(OptimizeMode::LITE_RUNTIME),
4948                _ => ::std::option::Option::None
4949            }
4950        }
4951
4952        const VALUES: &'static [OptimizeMode] = &[
4953            OptimizeMode::SPEED,
4954            OptimizeMode::CODE_SIZE,
4955            OptimizeMode::LITE_RUNTIME,
4956        ];
4957    }
4958
4959    impl crate::EnumFull for OptimizeMode {
4960        fn enum_descriptor() -> crate::reflect::EnumDescriptor {
4961            static descriptor: crate::rt::Lazy<crate::reflect::EnumDescriptor> = crate::rt::Lazy::new();
4962            descriptor.get(|| super::file_descriptor().enum_by_package_relative_name("FileOptions.OptimizeMode").unwrap()).clone()
4963        }
4964
4965        fn descriptor(&self) -> crate::reflect::EnumValueDescriptor {
4966            let index = match self {
4967                OptimizeMode::SPEED => 0,
4968                OptimizeMode::CODE_SIZE => 1,
4969                OptimizeMode::LITE_RUNTIME => 2,
4970            };
4971            Self::enum_descriptor().value_by_index(index)
4972        }
4973    }
4974
4975    // Note, `Default` is implemented although default value is not 0
4976    impl ::std::default::Default for OptimizeMode {
4977        fn default() -> Self {
4978            OptimizeMode::SPEED
4979        }
4980    }
4981
4982    impl OptimizeMode {
4983        pub(in super) fn generated_enum_descriptor_data() -> crate::reflect::GeneratedEnumDescriptorData {
4984            crate::reflect::GeneratedEnumDescriptorData::new::<OptimizeMode>("FileOptions.OptimizeMode")
4985        }
4986    }
4987}
4988
4989// @@protoc_insertion_point(message:google.protobuf.MessageOptions)
4990#[derive(PartialEq,Clone,Default,Debug)]
4991pub struct MessageOptions {
4992    // message fields
4993    // @@protoc_insertion_point(field:google.protobuf.MessageOptions.message_set_wire_format)
4994    pub message_set_wire_format: ::std::option::Option<bool>,
4995    ///  Disables the generation of the standard "descriptor()" accessor, which can
4996    ///  conflict with a field of the same name.  This is meant to make migration
4997    ///  from proto1 easier; new code should avoid fields named "descriptor".
4998    // @@protoc_insertion_point(field:google.protobuf.MessageOptions.no_standard_descriptor_accessor)
4999    pub no_standard_descriptor_accessor: ::std::option::Option<bool>,
5000    ///  Is this message deprecated?
5001    ///  Depending on the target platform, this can emit Deprecated annotations
5002    ///  for the message, or it will be completely ignored; in the very least,
5003    ///  this is a formalization for deprecating messages.
5004    // @@protoc_insertion_point(field:google.protobuf.MessageOptions.deprecated)
5005    pub deprecated: ::std::option::Option<bool>,
5006    // @@protoc_insertion_point(field:google.protobuf.MessageOptions.map_entry)
5007    pub map_entry: ::std::option::Option<bool>,
5008    ///  The parser stores options it doesn't recognize here. See above.
5009    // @@protoc_insertion_point(field:google.protobuf.MessageOptions.uninterpreted_option)
5010    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
5011    // special fields
5012    // @@protoc_insertion_point(special_field:google.protobuf.MessageOptions.special_fields)
5013    pub special_fields: crate::SpecialFields,
5014}
5015
5016impl<'a> ::std::default::Default for &'a MessageOptions {
5017    fn default() -> &'a MessageOptions {
5018        <MessageOptions as crate::Message>::default_instance()
5019    }
5020}
5021
5022impl MessageOptions {
5023    pub fn new() -> MessageOptions {
5024        ::std::default::Default::default()
5025    }
5026
5027    // optional bool message_set_wire_format = 1;
5028
5029    pub fn message_set_wire_format(&self) -> bool {
5030        self.message_set_wire_format.unwrap_or(false)
5031    }
5032
5033    pub fn clear_message_set_wire_format(&mut self) {
5034        self.message_set_wire_format = ::std::option::Option::None;
5035    }
5036
5037    pub fn has_message_set_wire_format(&self) -> bool {
5038        self.message_set_wire_format.is_some()
5039    }
5040
5041    // Param is passed by value, moved
5042    pub fn set_message_set_wire_format(&mut self, v: bool) {
5043        self.message_set_wire_format = ::std::option::Option::Some(v);
5044    }
5045
5046    // optional bool no_standard_descriptor_accessor = 2;
5047
5048    pub fn no_standard_descriptor_accessor(&self) -> bool {
5049        self.no_standard_descriptor_accessor.unwrap_or(false)
5050    }
5051
5052    pub fn clear_no_standard_descriptor_accessor(&mut self) {
5053        self.no_standard_descriptor_accessor = ::std::option::Option::None;
5054    }
5055
5056    pub fn has_no_standard_descriptor_accessor(&self) -> bool {
5057        self.no_standard_descriptor_accessor.is_some()
5058    }
5059
5060    // Param is passed by value, moved
5061    pub fn set_no_standard_descriptor_accessor(&mut self, v: bool) {
5062        self.no_standard_descriptor_accessor = ::std::option::Option::Some(v);
5063    }
5064
5065    // optional bool deprecated = 3;
5066
5067    pub fn deprecated(&self) -> bool {
5068        self.deprecated.unwrap_or(false)
5069    }
5070
5071    pub fn clear_deprecated(&mut self) {
5072        self.deprecated = ::std::option::Option::None;
5073    }
5074
5075    pub fn has_deprecated(&self) -> bool {
5076        self.deprecated.is_some()
5077    }
5078
5079    // Param is passed by value, moved
5080    pub fn set_deprecated(&mut self, v: bool) {
5081        self.deprecated = ::std::option::Option::Some(v);
5082    }
5083
5084    // optional bool map_entry = 7;
5085
5086    pub fn map_entry(&self) -> bool {
5087        self.map_entry.unwrap_or(false)
5088    }
5089
5090    pub fn clear_map_entry(&mut self) {
5091        self.map_entry = ::std::option::Option::None;
5092    }
5093
5094    pub fn has_map_entry(&self) -> bool {
5095        self.map_entry.is_some()
5096    }
5097
5098    // Param is passed by value, moved
5099    pub fn set_map_entry(&mut self, v: bool) {
5100        self.map_entry = ::std::option::Option::Some(v);
5101    }
5102
5103    fn generated_message_descriptor_data() -> crate::reflect::GeneratedMessageDescriptorData {
5104        let mut fields = ::std::vec::Vec::with_capacity(5);
5105        let mut oneofs = ::std::vec::Vec::with_capacity(0);
5106        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
5107            "message_set_wire_format",
5108            |m: &MessageOptions| { &m.message_set_wire_format },
5109            |m: &mut MessageOptions| { &mut m.message_set_wire_format },
5110        ));
5111        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
5112            "no_standard_descriptor_accessor",
5113            |m: &MessageOptions| { &m.no_standard_descriptor_accessor },
5114            |m: &mut MessageOptions| { &mut m.no_standard_descriptor_accessor },
5115        ));
5116        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
5117            "deprecated",
5118            |m: &MessageOptions| { &m.deprecated },
5119            |m: &mut MessageOptions| { &mut m.deprecated },
5120        ));
5121        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
5122            "map_entry",
5123            |m: &MessageOptions| { &m.map_entry },
5124            |m: &mut MessageOptions| { &mut m.map_entry },
5125        ));
5126        fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
5127            "uninterpreted_option",
5128            |m: &MessageOptions| { &m.uninterpreted_option },
5129            |m: &mut MessageOptions| { &mut m.uninterpreted_option },
5130        ));
5131        crate::reflect::GeneratedMessageDescriptorData::new_2::<MessageOptions>(
5132            "MessageOptions",
5133            fields,
5134            oneofs,
5135        )
5136    }
5137}
5138
5139impl crate::Message for MessageOptions {
5140    const NAME: &'static str = "MessageOptions";
5141
5142    fn is_initialized(&self) -> bool {
5143        for v in &self.uninterpreted_option {
5144            if !v.is_initialized() {
5145                return false;
5146            }
5147        };
5148        true
5149    }
5150
5151    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::Result<()> {
5152        while let Some(tag) = is.read_raw_tag_or_eof()? {
5153            match tag {
5154                8 => {
5155                    self.message_set_wire_format = ::std::option::Option::Some(is.read_bool()?);
5156                },
5157                16 => {
5158                    self.no_standard_descriptor_accessor = ::std::option::Option::Some(is.read_bool()?);
5159                },
5160                24 => {
5161                    self.deprecated = ::std::option::Option::Some(is.read_bool()?);
5162                },
5163                56 => {
5164                    self.map_entry = ::std::option::Option::Some(is.read_bool()?);
5165                },
5166                7994 => {
5167                    self.uninterpreted_option.push(is.read_message()?);
5168                },
5169                tag => {
5170                    crate::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
5171                },
5172            };
5173        }
5174        ::std::result::Result::Ok(())
5175    }
5176
5177    // Compute sizes of nested messages
5178    #[allow(unused_variables)]
5179    fn compute_size(&self) -> u64 {
5180        let mut my_size = 0;
5181        if let Some(v) = self.message_set_wire_format {
5182            my_size += 1 + 1;
5183        }
5184        if let Some(v) = self.no_standard_descriptor_accessor {
5185            my_size += 1 + 1;
5186        }
5187        if let Some(v) = self.deprecated {
5188            my_size += 1 + 1;
5189        }
5190        if let Some(v) = self.map_entry {
5191            my_size += 1 + 1;
5192        }
5193        for value in &self.uninterpreted_option {
5194            let len = value.compute_size();
5195            my_size += 2 + crate::rt::compute_raw_varint64_size(len) + len;
5196        };
5197        my_size += crate::rt::unknown_fields_size(self.special_fields.unknown_fields());
5198        self.special_fields.cached_size().set(my_size as u32);
5199        my_size
5200    }
5201
5202    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::Result<()> {
5203        if let Some(v) = self.message_set_wire_format {
5204            os.write_bool(1, v)?;
5205        }
5206        if let Some(v) = self.no_standard_descriptor_accessor {
5207            os.write_bool(2, v)?;
5208        }
5209        if let Some(v) = self.deprecated {
5210            os.write_bool(3, v)?;
5211        }
5212        if let Some(v) = self.map_entry {
5213            os.write_bool(7, v)?;
5214        }
5215        for v in &self.uninterpreted_option {
5216            crate::rt::write_message_field_with_cached_size(999, v, os)?;
5217        };
5218        os.write_unknown_fields(self.special_fields.unknown_fields())?;
5219        ::std::result::Result::Ok(())
5220    }
5221
5222    fn special_fields(&self) -> &crate::SpecialFields {
5223        &self.special_fields
5224    }
5225
5226    fn mut_special_fields(&mut self) -> &mut crate::SpecialFields {
5227        &mut self.special_fields
5228    }
5229
5230    fn new() -> MessageOptions {
5231        MessageOptions::new()
5232    }
5233
5234    fn clear(&mut self) {
5235        self.message_set_wire_format = ::std::option::Option::None;
5236        self.no_standard_descriptor_accessor = ::std::option::Option::None;
5237        self.deprecated = ::std::option::Option::None;
5238        self.map_entry = ::std::option::Option::None;
5239        self.uninterpreted_option.clear();
5240        self.special_fields.clear();
5241    }
5242
5243    fn default_instance() -> &'static MessageOptions {
5244        static instance: MessageOptions = MessageOptions {
5245            message_set_wire_format: ::std::option::Option::None,
5246            no_standard_descriptor_accessor: ::std::option::Option::None,
5247            deprecated: ::std::option::Option::None,
5248            map_entry: ::std::option::Option::None,
5249            uninterpreted_option: ::std::vec::Vec::new(),
5250            special_fields: crate::SpecialFields::new(),
5251        };
5252        &instance
5253    }
5254}
5255
5256impl crate::MessageFull for MessageOptions {
5257    fn descriptor() -> crate::reflect::MessageDescriptor {
5258        static descriptor: crate::rt::Lazy<crate::reflect::MessageDescriptor> = crate::rt::Lazy::new();
5259        descriptor.get(|| file_descriptor().message_by_package_relative_name("MessageOptions").unwrap()).clone()
5260    }
5261}
5262
5263impl ::std::fmt::Display for MessageOptions {
5264    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5265        crate::text_format::fmt(self, f)
5266    }
5267}
5268
5269impl crate::reflect::ProtobufValue for MessageOptions {
5270    type RuntimeType = crate::reflect::rt::RuntimeTypeMessage<Self>;
5271}
5272
5273// @@protoc_insertion_point(message:google.protobuf.FieldOptions)
5274#[derive(PartialEq,Clone,Default,Debug)]
5275pub struct FieldOptions {
5276    // message fields
5277    ///  The ctype option instructs the C++ code generator to use a different
5278    ///  representation of the field than it normally would.  See the specific
5279    ///  options below.  This option is not yet implemented in the open source
5280    ///  release -- sorry, we'll try to include it in a future version!
5281    // @@protoc_insertion_point(field:google.protobuf.FieldOptions.ctype)
5282    pub ctype: ::std::option::Option<crate::EnumOrUnknown<field_options::CType>>,
5283    ///  The packed option can be enabled for repeated primitive fields to enable
5284    ///  a more efficient representation on the wire. Rather than repeatedly
5285    ///  writing the tag and type for each element, the entire array is encoded as
5286    ///  a single length-delimited blob. In proto3, only explicit setting it to
5287    ///  false will avoid using packed encoding.
5288    // @@protoc_insertion_point(field:google.protobuf.FieldOptions.packed)
5289    pub packed: ::std::option::Option<bool>,
5290    ///  The jstype option determines the JavaScript type used for values of the
5291    ///  field.  The option is permitted only for 64 bit integral and fixed types
5292    ///  (int64, uint64, sint64, fixed64, sfixed64).  A field with jstype JS_STRING
5293    ///  is represented as JavaScript string, which avoids loss of precision that
5294    ///  can happen when a large value is converted to a floating point JavaScript.
5295    ///  Specifying JS_NUMBER for the jstype causes the generated JavaScript code to
5296    ///  use the JavaScript "number" type.  The behavior of the default option
5297    ///  JS_NORMAL is implementation dependent.
5298    ///
5299    ///  This option is an enum to permit additional types to be added, e.g.
5300    ///  goog.math.Integer.
5301    // @@protoc_insertion_point(field:google.protobuf.FieldOptions.jstype)
5302    pub jstype: ::std::option::Option<crate::EnumOrUnknown<field_options::JSType>>,
5303    ///  Should this field be parsed lazily?  Lazy applies only to message-type
5304    ///  fields.  It means that when the outer message is initially parsed, the
5305    ///  inner message's contents will not be parsed but instead stored in encoded
5306    ///  form.  The inner message will actually be parsed when it is first accessed.
5307    ///
5308    ///  This is only a hint.  Implementations are free to choose whether to use
5309    ///  eager or lazy parsing regardless of the value of this option.  However,
5310    ///  setting this option true suggests that the protocol author believes that
5311    ///  using lazy parsing on this field is worth the additional bookkeeping
5312    ///  overhead typically needed to implement it.
5313    ///
5314    ///  This option does not affect the public interface of any generated code;
5315    ///  all method signatures remain the same.  Furthermore, thread-safety of the
5316    ///  interface is not affected by this option; const methods remain safe to
5317    ///  call from multiple threads concurrently, while non-const methods continue
5318    ///  to require exclusive access.
5319    ///
5320    ///
5321    ///  Note that implementations may choose not to check required fields within
5322    ///  a lazy sub-message.  That is, calling IsInitialized() on the outer message
5323    ///  may return true even if the inner message has missing required fields.
5324    ///  This is necessary because otherwise the inner message would have to be
5325    ///  parsed in order to perform the check, defeating the purpose of lazy
5326    ///  parsing.  An implementation which chooses not to check required fields
5327    ///  must be consistent about it.  That is, for any particular sub-message, the
5328    ///  implementation must either *always* check its required fields, or *never*
5329    ///  check its required fields, regardless of whether or not the message has
5330    ///  been parsed.
5331    // @@protoc_insertion_point(field:google.protobuf.FieldOptions.lazy)
5332    pub lazy: ::std::option::Option<bool>,
5333    ///  Is this field deprecated?
5334    ///  Depending on the target platform, this can emit Deprecated annotations
5335    ///  for accessors, or it will be completely ignored; in the very least, this
5336    ///  is a formalization for deprecating fields.
5337    // @@protoc_insertion_point(field:google.protobuf.FieldOptions.deprecated)
5338    pub deprecated: ::std::option::Option<bool>,
5339    ///  For Google-internal migration only. Do not use.
5340    // @@protoc_insertion_point(field:google.protobuf.FieldOptions.weak)
5341    pub weak: ::std::option::Option<bool>,
5342    ///  The parser stores options it doesn't recognize here. See above.
5343    // @@protoc_insertion_point(field:google.protobuf.FieldOptions.uninterpreted_option)
5344    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
5345    // special fields
5346    // @@protoc_insertion_point(special_field:google.protobuf.FieldOptions.special_fields)
5347    pub special_fields: crate::SpecialFields,
5348}
5349
5350impl<'a> ::std::default::Default for &'a FieldOptions {
5351    fn default() -> &'a FieldOptions {
5352        <FieldOptions as crate::Message>::default_instance()
5353    }
5354}
5355
5356impl FieldOptions {
5357    pub fn new() -> FieldOptions {
5358        ::std::default::Default::default()
5359    }
5360
5361    // optional .google.protobuf.FieldOptions.CType ctype = 1;
5362
5363    pub fn ctype(&self) -> field_options::CType {
5364        match self.ctype {
5365            Some(e) => e.enum_value_or(field_options::CType::STRING),
5366            None => field_options::CType::STRING,
5367        }
5368    }
5369
5370    pub fn clear_ctype(&mut self) {
5371        self.ctype = ::std::option::Option::None;
5372    }
5373
5374    pub fn has_ctype(&self) -> bool {
5375        self.ctype.is_some()
5376    }
5377
5378    // Param is passed by value, moved
5379    pub fn set_ctype(&mut self, v: field_options::CType) {
5380        self.ctype = ::std::option::Option::Some(crate::EnumOrUnknown::new(v));
5381    }
5382
5383    // optional bool packed = 2;
5384
5385    pub fn packed(&self) -> bool {
5386        self.packed.unwrap_or(false)
5387    }
5388
5389    pub fn clear_packed(&mut self) {
5390        self.packed = ::std::option::Option::None;
5391    }
5392
5393    pub fn has_packed(&self) -> bool {
5394        self.packed.is_some()
5395    }
5396
5397    // Param is passed by value, moved
5398    pub fn set_packed(&mut self, v: bool) {
5399        self.packed = ::std::option::Option::Some(v);
5400    }
5401
5402    // optional .google.protobuf.FieldOptions.JSType jstype = 6;
5403
5404    pub fn jstype(&self) -> field_options::JSType {
5405        match self.jstype {
5406            Some(e) => e.enum_value_or(field_options::JSType::JS_NORMAL),
5407            None => field_options::JSType::JS_NORMAL,
5408        }
5409    }
5410
5411    pub fn clear_jstype(&mut self) {
5412        self.jstype = ::std::option::Option::None;
5413    }
5414
5415    pub fn has_jstype(&self) -> bool {
5416        self.jstype.is_some()
5417    }
5418
5419    // Param is passed by value, moved
5420    pub fn set_jstype(&mut self, v: field_options::JSType) {
5421        self.jstype = ::std::option::Option::Some(crate::EnumOrUnknown::new(v));
5422    }
5423
5424    // optional bool lazy = 5;
5425
5426    pub fn lazy(&self) -> bool {
5427        self.lazy.unwrap_or(false)
5428    }
5429
5430    pub fn clear_lazy(&mut self) {
5431        self.lazy = ::std::option::Option::None;
5432    }
5433
5434    pub fn has_lazy(&self) -> bool {
5435        self.lazy.is_some()
5436    }
5437
5438    // Param is passed by value, moved
5439    pub fn set_lazy(&mut self, v: bool) {
5440        self.lazy = ::std::option::Option::Some(v);
5441    }
5442
5443    // optional bool deprecated = 3;
5444
5445    pub fn deprecated(&self) -> bool {
5446        self.deprecated.unwrap_or(false)
5447    }
5448
5449    pub fn clear_deprecated(&mut self) {
5450        self.deprecated = ::std::option::Option::None;
5451    }
5452
5453    pub fn has_deprecated(&self) -> bool {
5454        self.deprecated.is_some()
5455    }
5456
5457    // Param is passed by value, moved
5458    pub fn set_deprecated(&mut self, v: bool) {
5459        self.deprecated = ::std::option::Option::Some(v);
5460    }
5461
5462    // optional bool weak = 10;
5463
5464    pub fn weak(&self) -> bool {
5465        self.weak.unwrap_or(false)
5466    }
5467
5468    pub fn clear_weak(&mut self) {
5469        self.weak = ::std::option::Option::None;
5470    }
5471
5472    pub fn has_weak(&self) -> bool {
5473        self.weak.is_some()
5474    }
5475
5476    // Param is passed by value, moved
5477    pub fn set_weak(&mut self, v: bool) {
5478        self.weak = ::std::option::Option::Some(v);
5479    }
5480
5481    fn generated_message_descriptor_data() -> crate::reflect::GeneratedMessageDescriptorData {
5482        let mut fields = ::std::vec::Vec::with_capacity(7);
5483        let mut oneofs = ::std::vec::Vec::with_capacity(0);
5484        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
5485            "ctype",
5486            |m: &FieldOptions| { &m.ctype },
5487            |m: &mut FieldOptions| { &mut m.ctype },
5488        ));
5489        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
5490            "packed",
5491            |m: &FieldOptions| { &m.packed },
5492            |m: &mut FieldOptions| { &mut m.packed },
5493        ));
5494        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
5495            "jstype",
5496            |m: &FieldOptions| { &m.jstype },
5497            |m: &mut FieldOptions| { &mut m.jstype },
5498        ));
5499        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
5500            "lazy",
5501            |m: &FieldOptions| { &m.lazy },
5502            |m: &mut FieldOptions| { &mut m.lazy },
5503        ));
5504        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
5505            "deprecated",
5506            |m: &FieldOptions| { &m.deprecated },
5507            |m: &mut FieldOptions| { &mut m.deprecated },
5508        ));
5509        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
5510            "weak",
5511            |m: &FieldOptions| { &m.weak },
5512            |m: &mut FieldOptions| { &mut m.weak },
5513        ));
5514        fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
5515            "uninterpreted_option",
5516            |m: &FieldOptions| { &m.uninterpreted_option },
5517            |m: &mut FieldOptions| { &mut m.uninterpreted_option },
5518        ));
5519        crate::reflect::GeneratedMessageDescriptorData::new_2::<FieldOptions>(
5520            "FieldOptions",
5521            fields,
5522            oneofs,
5523        )
5524    }
5525}
5526
5527impl crate::Message for FieldOptions {
5528    const NAME: &'static str = "FieldOptions";
5529
5530    fn is_initialized(&self) -> bool {
5531        for v in &self.uninterpreted_option {
5532            if !v.is_initialized() {
5533                return false;
5534            }
5535        };
5536        true
5537    }
5538
5539    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::Result<()> {
5540        while let Some(tag) = is.read_raw_tag_or_eof()? {
5541            match tag {
5542                8 => {
5543                    self.ctype = ::std::option::Option::Some(is.read_enum_or_unknown()?);
5544                },
5545                16 => {
5546                    self.packed = ::std::option::Option::Some(is.read_bool()?);
5547                },
5548                48 => {
5549                    self.jstype = ::std::option::Option::Some(is.read_enum_or_unknown()?);
5550                },
5551                40 => {
5552                    self.lazy = ::std::option::Option::Some(is.read_bool()?);
5553                },
5554                24 => {
5555                    self.deprecated = ::std::option::Option::Some(is.read_bool()?);
5556                },
5557                80 => {
5558                    self.weak = ::std::option::Option::Some(is.read_bool()?);
5559                },
5560                7994 => {
5561                    self.uninterpreted_option.push(is.read_message()?);
5562                },
5563                tag => {
5564                    crate::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
5565                },
5566            };
5567        }
5568        ::std::result::Result::Ok(())
5569    }
5570
5571    // Compute sizes of nested messages
5572    #[allow(unused_variables)]
5573    fn compute_size(&self) -> u64 {
5574        let mut my_size = 0;
5575        if let Some(v) = self.ctype {
5576            my_size += crate::rt::int32_size(1, v.value());
5577        }
5578        if let Some(v) = self.packed {
5579            my_size += 1 + 1;
5580        }
5581        if let Some(v) = self.jstype {
5582            my_size += crate::rt::int32_size(6, v.value());
5583        }
5584        if let Some(v) = self.lazy {
5585            my_size += 1 + 1;
5586        }
5587        if let Some(v) = self.deprecated {
5588            my_size += 1 + 1;
5589        }
5590        if let Some(v) = self.weak {
5591            my_size += 1 + 1;
5592        }
5593        for value in &self.uninterpreted_option {
5594            let len = value.compute_size();
5595            my_size += 2 + crate::rt::compute_raw_varint64_size(len) + len;
5596        };
5597        my_size += crate::rt::unknown_fields_size(self.special_fields.unknown_fields());
5598        self.special_fields.cached_size().set(my_size as u32);
5599        my_size
5600    }
5601
5602    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::Result<()> {
5603        if let Some(v) = self.ctype {
5604            os.write_enum(1, crate::EnumOrUnknown::value(&v))?;
5605        }
5606        if let Some(v) = self.packed {
5607            os.write_bool(2, v)?;
5608        }
5609        if let Some(v) = self.jstype {
5610            os.write_enum(6, crate::EnumOrUnknown::value(&v))?;
5611        }
5612        if let Some(v) = self.lazy {
5613            os.write_bool(5, v)?;
5614        }
5615        if let Some(v) = self.deprecated {
5616            os.write_bool(3, v)?;
5617        }
5618        if let Some(v) = self.weak {
5619            os.write_bool(10, v)?;
5620        }
5621        for v in &self.uninterpreted_option {
5622            crate::rt::write_message_field_with_cached_size(999, v, os)?;
5623        };
5624        os.write_unknown_fields(self.special_fields.unknown_fields())?;
5625        ::std::result::Result::Ok(())
5626    }
5627
5628    fn special_fields(&self) -> &crate::SpecialFields {
5629        &self.special_fields
5630    }
5631
5632    fn mut_special_fields(&mut self) -> &mut crate::SpecialFields {
5633        &mut self.special_fields
5634    }
5635
5636    fn new() -> FieldOptions {
5637        FieldOptions::new()
5638    }
5639
5640    fn clear(&mut self) {
5641        self.ctype = ::std::option::Option::None;
5642        self.packed = ::std::option::Option::None;
5643        self.jstype = ::std::option::Option::None;
5644        self.lazy = ::std::option::Option::None;
5645        self.deprecated = ::std::option::Option::None;
5646        self.weak = ::std::option::Option::None;
5647        self.uninterpreted_option.clear();
5648        self.special_fields.clear();
5649    }
5650
5651    fn default_instance() -> &'static FieldOptions {
5652        static instance: FieldOptions = FieldOptions {
5653            ctype: ::std::option::Option::None,
5654            packed: ::std::option::Option::None,
5655            jstype: ::std::option::Option::None,
5656            lazy: ::std::option::Option::None,
5657            deprecated: ::std::option::Option::None,
5658            weak: ::std::option::Option::None,
5659            uninterpreted_option: ::std::vec::Vec::new(),
5660            special_fields: crate::SpecialFields::new(),
5661        };
5662        &instance
5663    }
5664}
5665
5666impl crate::MessageFull for FieldOptions {
5667    fn descriptor() -> crate::reflect::MessageDescriptor {
5668        static descriptor: crate::rt::Lazy<crate::reflect::MessageDescriptor> = crate::rt::Lazy::new();
5669        descriptor.get(|| file_descriptor().message_by_package_relative_name("FieldOptions").unwrap()).clone()
5670    }
5671}
5672
5673impl ::std::fmt::Display for FieldOptions {
5674    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5675        crate::text_format::fmt(self, f)
5676    }
5677}
5678
5679impl crate::reflect::ProtobufValue for FieldOptions {
5680    type RuntimeType = crate::reflect::rt::RuntimeTypeMessage<Self>;
5681}
5682
5683/// Nested message and enums of message `FieldOptions`
5684pub mod field_options {
5685    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
5686    // @@protoc_insertion_point(enum:google.protobuf.FieldOptions.CType)
5687    pub enum CType {
5688        // @@protoc_insertion_point(enum_value:google.protobuf.FieldOptions.CType.STRING)
5689        STRING = 0,
5690        // @@protoc_insertion_point(enum_value:google.protobuf.FieldOptions.CType.CORD)
5691        CORD = 1,
5692        // @@protoc_insertion_point(enum_value:google.protobuf.FieldOptions.CType.STRING_PIECE)
5693        STRING_PIECE = 2,
5694    }
5695
5696    impl crate::Enum for CType {
5697        const NAME: &'static str = "CType";
5698
5699        fn value(&self) -> i32 {
5700            *self as i32
5701        }
5702
5703        fn from_i32(value: i32) -> ::std::option::Option<CType> {
5704            match value {
5705                0 => ::std::option::Option::Some(CType::STRING),
5706                1 => ::std::option::Option::Some(CType::CORD),
5707                2 => ::std::option::Option::Some(CType::STRING_PIECE),
5708                _ => ::std::option::Option::None
5709            }
5710        }
5711
5712        fn from_str(str: &str) -> ::std::option::Option<CType> {
5713            match str {
5714                "STRING" => ::std::option::Option::Some(CType::STRING),
5715                "CORD" => ::std::option::Option::Some(CType::CORD),
5716                "STRING_PIECE" => ::std::option::Option::Some(CType::STRING_PIECE),
5717                _ => ::std::option::Option::None
5718            }
5719        }
5720
5721        const VALUES: &'static [CType] = &[
5722            CType::STRING,
5723            CType::CORD,
5724            CType::STRING_PIECE,
5725        ];
5726    }
5727
5728    impl crate::EnumFull for CType {
5729        fn enum_descriptor() -> crate::reflect::EnumDescriptor {
5730            static descriptor: crate::rt::Lazy<crate::reflect::EnumDescriptor> = crate::rt::Lazy::new();
5731            descriptor.get(|| super::file_descriptor().enum_by_package_relative_name("FieldOptions.CType").unwrap()).clone()
5732        }
5733
5734        fn descriptor(&self) -> crate::reflect::EnumValueDescriptor {
5735            let index = *self as usize;
5736            Self::enum_descriptor().value_by_index(index)
5737        }
5738    }
5739
5740    impl ::std::default::Default for CType {
5741        fn default() -> Self {
5742            CType::STRING
5743        }
5744    }
5745
5746    impl CType {
5747        pub(in super) fn generated_enum_descriptor_data() -> crate::reflect::GeneratedEnumDescriptorData {
5748            crate::reflect::GeneratedEnumDescriptorData::new::<CType>("FieldOptions.CType")
5749        }
5750    }
5751
5752    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
5753    // @@protoc_insertion_point(enum:google.protobuf.FieldOptions.JSType)
5754    pub enum JSType {
5755        // @@protoc_insertion_point(enum_value:google.protobuf.FieldOptions.JSType.JS_NORMAL)
5756        JS_NORMAL = 0,
5757        // @@protoc_insertion_point(enum_value:google.protobuf.FieldOptions.JSType.JS_STRING)
5758        JS_STRING = 1,
5759        // @@protoc_insertion_point(enum_value:google.protobuf.FieldOptions.JSType.JS_NUMBER)
5760        JS_NUMBER = 2,
5761    }
5762
5763    impl crate::Enum for JSType {
5764        const NAME: &'static str = "JSType";
5765
5766        fn value(&self) -> i32 {
5767            *self as i32
5768        }
5769
5770        fn from_i32(value: i32) -> ::std::option::Option<JSType> {
5771            match value {
5772                0 => ::std::option::Option::Some(JSType::JS_NORMAL),
5773                1 => ::std::option::Option::Some(JSType::JS_STRING),
5774                2 => ::std::option::Option::Some(JSType::JS_NUMBER),
5775                _ => ::std::option::Option::None
5776            }
5777        }
5778
5779        fn from_str(str: &str) -> ::std::option::Option<JSType> {
5780            match str {
5781                "JS_NORMAL" => ::std::option::Option::Some(JSType::JS_NORMAL),
5782                "JS_STRING" => ::std::option::Option::Some(JSType::JS_STRING),
5783                "JS_NUMBER" => ::std::option::Option::Some(JSType::JS_NUMBER),
5784                _ => ::std::option::Option::None
5785            }
5786        }
5787
5788        const VALUES: &'static [JSType] = &[
5789            JSType::JS_NORMAL,
5790            JSType::JS_STRING,
5791            JSType::JS_NUMBER,
5792        ];
5793    }
5794
5795    impl crate::EnumFull for JSType {
5796        fn enum_descriptor() -> crate::reflect::EnumDescriptor {
5797            static descriptor: crate::rt::Lazy<crate::reflect::EnumDescriptor> = crate::rt::Lazy::new();
5798            descriptor.get(|| super::file_descriptor().enum_by_package_relative_name("FieldOptions.JSType").unwrap()).clone()
5799        }
5800
5801        fn descriptor(&self) -> crate::reflect::EnumValueDescriptor {
5802            let index = *self as usize;
5803            Self::enum_descriptor().value_by_index(index)
5804        }
5805    }
5806
5807    impl ::std::default::Default for JSType {
5808        fn default() -> Self {
5809            JSType::JS_NORMAL
5810        }
5811    }
5812
5813    impl JSType {
5814        pub(in super) fn generated_enum_descriptor_data() -> crate::reflect::GeneratedEnumDescriptorData {
5815            crate::reflect::GeneratedEnumDescriptorData::new::<JSType>("FieldOptions.JSType")
5816        }
5817    }
5818}
5819
5820// @@protoc_insertion_point(message:google.protobuf.OneofOptions)
5821#[derive(PartialEq,Clone,Default,Debug)]
5822pub struct OneofOptions {
5823    // message fields
5824    ///  The parser stores options it doesn't recognize here. See above.
5825    // @@protoc_insertion_point(field:google.protobuf.OneofOptions.uninterpreted_option)
5826    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
5827    // special fields
5828    // @@protoc_insertion_point(special_field:google.protobuf.OneofOptions.special_fields)
5829    pub special_fields: crate::SpecialFields,
5830}
5831
5832impl<'a> ::std::default::Default for &'a OneofOptions {
5833    fn default() -> &'a OneofOptions {
5834        <OneofOptions as crate::Message>::default_instance()
5835    }
5836}
5837
5838impl OneofOptions {
5839    pub fn new() -> OneofOptions {
5840        ::std::default::Default::default()
5841    }
5842
5843    fn generated_message_descriptor_data() -> crate::reflect::GeneratedMessageDescriptorData {
5844        let mut fields = ::std::vec::Vec::with_capacity(1);
5845        let mut oneofs = ::std::vec::Vec::with_capacity(0);
5846        fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
5847            "uninterpreted_option",
5848            |m: &OneofOptions| { &m.uninterpreted_option },
5849            |m: &mut OneofOptions| { &mut m.uninterpreted_option },
5850        ));
5851        crate::reflect::GeneratedMessageDescriptorData::new_2::<OneofOptions>(
5852            "OneofOptions",
5853            fields,
5854            oneofs,
5855        )
5856    }
5857}
5858
5859impl crate::Message for OneofOptions {
5860    const NAME: &'static str = "OneofOptions";
5861
5862    fn is_initialized(&self) -> bool {
5863        for v in &self.uninterpreted_option {
5864            if !v.is_initialized() {
5865                return false;
5866            }
5867        };
5868        true
5869    }
5870
5871    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::Result<()> {
5872        while let Some(tag) = is.read_raw_tag_or_eof()? {
5873            match tag {
5874                7994 => {
5875                    self.uninterpreted_option.push(is.read_message()?);
5876                },
5877                tag => {
5878                    crate::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
5879                },
5880            };
5881        }
5882        ::std::result::Result::Ok(())
5883    }
5884
5885    // Compute sizes of nested messages
5886    #[allow(unused_variables)]
5887    fn compute_size(&self) -> u64 {
5888        let mut my_size = 0;
5889        for value in &self.uninterpreted_option {
5890            let len = value.compute_size();
5891            my_size += 2 + crate::rt::compute_raw_varint64_size(len) + len;
5892        };
5893        my_size += crate::rt::unknown_fields_size(self.special_fields.unknown_fields());
5894        self.special_fields.cached_size().set(my_size as u32);
5895        my_size
5896    }
5897
5898    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::Result<()> {
5899        for v in &self.uninterpreted_option {
5900            crate::rt::write_message_field_with_cached_size(999, v, os)?;
5901        };
5902        os.write_unknown_fields(self.special_fields.unknown_fields())?;
5903        ::std::result::Result::Ok(())
5904    }
5905
5906    fn special_fields(&self) -> &crate::SpecialFields {
5907        &self.special_fields
5908    }
5909
5910    fn mut_special_fields(&mut self) -> &mut crate::SpecialFields {
5911        &mut self.special_fields
5912    }
5913
5914    fn new() -> OneofOptions {
5915        OneofOptions::new()
5916    }
5917
5918    fn clear(&mut self) {
5919        self.uninterpreted_option.clear();
5920        self.special_fields.clear();
5921    }
5922
5923    fn default_instance() -> &'static OneofOptions {
5924        static instance: OneofOptions = OneofOptions {
5925            uninterpreted_option: ::std::vec::Vec::new(),
5926            special_fields: crate::SpecialFields::new(),
5927        };
5928        &instance
5929    }
5930}
5931
5932impl crate::MessageFull for OneofOptions {
5933    fn descriptor() -> crate::reflect::MessageDescriptor {
5934        static descriptor: crate::rt::Lazy<crate::reflect::MessageDescriptor> = crate::rt::Lazy::new();
5935        descriptor.get(|| file_descriptor().message_by_package_relative_name("OneofOptions").unwrap()).clone()
5936    }
5937}
5938
5939impl ::std::fmt::Display for OneofOptions {
5940    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5941        crate::text_format::fmt(self, f)
5942    }
5943}
5944
5945impl crate::reflect::ProtobufValue for OneofOptions {
5946    type RuntimeType = crate::reflect::rt::RuntimeTypeMessage<Self>;
5947}
5948
5949// @@protoc_insertion_point(message:google.protobuf.EnumOptions)
5950#[derive(PartialEq,Clone,Default,Debug)]
5951pub struct EnumOptions {
5952    // message fields
5953    ///  Set this option to true to allow mapping different tag names to the same
5954    ///  value.
5955    // @@protoc_insertion_point(field:google.protobuf.EnumOptions.allow_alias)
5956    pub allow_alias: ::std::option::Option<bool>,
5957    ///  Is this enum deprecated?
5958    ///  Depending on the target platform, this can emit Deprecated annotations
5959    ///  for the enum, or it will be completely ignored; in the very least, this
5960    ///  is a formalization for deprecating enums.
5961    // @@protoc_insertion_point(field:google.protobuf.EnumOptions.deprecated)
5962    pub deprecated: ::std::option::Option<bool>,
5963    ///  The parser stores options it doesn't recognize here. See above.
5964    // @@protoc_insertion_point(field:google.protobuf.EnumOptions.uninterpreted_option)
5965    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
5966    // special fields
5967    // @@protoc_insertion_point(special_field:google.protobuf.EnumOptions.special_fields)
5968    pub special_fields: crate::SpecialFields,
5969}
5970
5971impl<'a> ::std::default::Default for &'a EnumOptions {
5972    fn default() -> &'a EnumOptions {
5973        <EnumOptions as crate::Message>::default_instance()
5974    }
5975}
5976
5977impl EnumOptions {
5978    pub fn new() -> EnumOptions {
5979        ::std::default::Default::default()
5980    }
5981
5982    // optional bool allow_alias = 2;
5983
5984    pub fn allow_alias(&self) -> bool {
5985        self.allow_alias.unwrap_or(false)
5986    }
5987
5988    pub fn clear_allow_alias(&mut self) {
5989        self.allow_alias = ::std::option::Option::None;
5990    }
5991
5992    pub fn has_allow_alias(&self) -> bool {
5993        self.allow_alias.is_some()
5994    }
5995
5996    // Param is passed by value, moved
5997    pub fn set_allow_alias(&mut self, v: bool) {
5998        self.allow_alias = ::std::option::Option::Some(v);
5999    }
6000
6001    // optional bool deprecated = 3;
6002
6003    pub fn deprecated(&self) -> bool {
6004        self.deprecated.unwrap_or(false)
6005    }
6006
6007    pub fn clear_deprecated(&mut self) {
6008        self.deprecated = ::std::option::Option::None;
6009    }
6010
6011    pub fn has_deprecated(&self) -> bool {
6012        self.deprecated.is_some()
6013    }
6014
6015    // Param is passed by value, moved
6016    pub fn set_deprecated(&mut self, v: bool) {
6017        self.deprecated = ::std::option::Option::Some(v);
6018    }
6019
6020    fn generated_message_descriptor_data() -> crate::reflect::GeneratedMessageDescriptorData {
6021        let mut fields = ::std::vec::Vec::with_capacity(3);
6022        let mut oneofs = ::std::vec::Vec::with_capacity(0);
6023        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
6024            "allow_alias",
6025            |m: &EnumOptions| { &m.allow_alias },
6026            |m: &mut EnumOptions| { &mut m.allow_alias },
6027        ));
6028        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
6029            "deprecated",
6030            |m: &EnumOptions| { &m.deprecated },
6031            |m: &mut EnumOptions| { &mut m.deprecated },
6032        ));
6033        fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
6034            "uninterpreted_option",
6035            |m: &EnumOptions| { &m.uninterpreted_option },
6036            |m: &mut EnumOptions| { &mut m.uninterpreted_option },
6037        ));
6038        crate::reflect::GeneratedMessageDescriptorData::new_2::<EnumOptions>(
6039            "EnumOptions",
6040            fields,
6041            oneofs,
6042        )
6043    }
6044}
6045
6046impl crate::Message for EnumOptions {
6047    const NAME: &'static str = "EnumOptions";
6048
6049    fn is_initialized(&self) -> bool {
6050        for v in &self.uninterpreted_option {
6051            if !v.is_initialized() {
6052                return false;
6053            }
6054        };
6055        true
6056    }
6057
6058    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::Result<()> {
6059        while let Some(tag) = is.read_raw_tag_or_eof()? {
6060            match tag {
6061                16 => {
6062                    self.allow_alias = ::std::option::Option::Some(is.read_bool()?);
6063                },
6064                24 => {
6065                    self.deprecated = ::std::option::Option::Some(is.read_bool()?);
6066                },
6067                7994 => {
6068                    self.uninterpreted_option.push(is.read_message()?);
6069                },
6070                tag => {
6071                    crate::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
6072                },
6073            };
6074        }
6075        ::std::result::Result::Ok(())
6076    }
6077
6078    // Compute sizes of nested messages
6079    #[allow(unused_variables)]
6080    fn compute_size(&self) -> u64 {
6081        let mut my_size = 0;
6082        if let Some(v) = self.allow_alias {
6083            my_size += 1 + 1;
6084        }
6085        if let Some(v) = self.deprecated {
6086            my_size += 1 + 1;
6087        }
6088        for value in &self.uninterpreted_option {
6089            let len = value.compute_size();
6090            my_size += 2 + crate::rt::compute_raw_varint64_size(len) + len;
6091        };
6092        my_size += crate::rt::unknown_fields_size(self.special_fields.unknown_fields());
6093        self.special_fields.cached_size().set(my_size as u32);
6094        my_size
6095    }
6096
6097    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::Result<()> {
6098        if let Some(v) = self.allow_alias {
6099            os.write_bool(2, v)?;
6100        }
6101        if let Some(v) = self.deprecated {
6102            os.write_bool(3, v)?;
6103        }
6104        for v in &self.uninterpreted_option {
6105            crate::rt::write_message_field_with_cached_size(999, v, os)?;
6106        };
6107        os.write_unknown_fields(self.special_fields.unknown_fields())?;
6108        ::std::result::Result::Ok(())
6109    }
6110
6111    fn special_fields(&self) -> &crate::SpecialFields {
6112        &self.special_fields
6113    }
6114
6115    fn mut_special_fields(&mut self) -> &mut crate::SpecialFields {
6116        &mut self.special_fields
6117    }
6118
6119    fn new() -> EnumOptions {
6120        EnumOptions::new()
6121    }
6122
6123    fn clear(&mut self) {
6124        self.allow_alias = ::std::option::Option::None;
6125        self.deprecated = ::std::option::Option::None;
6126        self.uninterpreted_option.clear();
6127        self.special_fields.clear();
6128    }
6129
6130    fn default_instance() -> &'static EnumOptions {
6131        static instance: EnumOptions = EnumOptions {
6132            allow_alias: ::std::option::Option::None,
6133            deprecated: ::std::option::Option::None,
6134            uninterpreted_option: ::std::vec::Vec::new(),
6135            special_fields: crate::SpecialFields::new(),
6136        };
6137        &instance
6138    }
6139}
6140
6141impl crate::MessageFull for EnumOptions {
6142    fn descriptor() -> crate::reflect::MessageDescriptor {
6143        static descriptor: crate::rt::Lazy<crate::reflect::MessageDescriptor> = crate::rt::Lazy::new();
6144        descriptor.get(|| file_descriptor().message_by_package_relative_name("EnumOptions").unwrap()).clone()
6145    }
6146}
6147
6148impl ::std::fmt::Display for EnumOptions {
6149    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6150        crate::text_format::fmt(self, f)
6151    }
6152}
6153
6154impl crate::reflect::ProtobufValue for EnumOptions {
6155    type RuntimeType = crate::reflect::rt::RuntimeTypeMessage<Self>;
6156}
6157
6158// @@protoc_insertion_point(message:google.protobuf.EnumValueOptions)
6159#[derive(PartialEq,Clone,Default,Debug)]
6160pub struct EnumValueOptions {
6161    // message fields
6162    ///  Is this enum value deprecated?
6163    ///  Depending on the target platform, this can emit Deprecated annotations
6164    ///  for the enum value, or it will be completely ignored; in the very least,
6165    ///  this is a formalization for deprecating enum values.
6166    // @@protoc_insertion_point(field:google.protobuf.EnumValueOptions.deprecated)
6167    pub deprecated: ::std::option::Option<bool>,
6168    ///  The parser stores options it doesn't recognize here. See above.
6169    // @@protoc_insertion_point(field:google.protobuf.EnumValueOptions.uninterpreted_option)
6170    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
6171    // special fields
6172    // @@protoc_insertion_point(special_field:google.protobuf.EnumValueOptions.special_fields)
6173    pub special_fields: crate::SpecialFields,
6174}
6175
6176impl<'a> ::std::default::Default for &'a EnumValueOptions {
6177    fn default() -> &'a EnumValueOptions {
6178        <EnumValueOptions as crate::Message>::default_instance()
6179    }
6180}
6181
6182impl EnumValueOptions {
6183    pub fn new() -> EnumValueOptions {
6184        ::std::default::Default::default()
6185    }
6186
6187    // optional bool deprecated = 1;
6188
6189    pub fn deprecated(&self) -> bool {
6190        self.deprecated.unwrap_or(false)
6191    }
6192
6193    pub fn clear_deprecated(&mut self) {
6194        self.deprecated = ::std::option::Option::None;
6195    }
6196
6197    pub fn has_deprecated(&self) -> bool {
6198        self.deprecated.is_some()
6199    }
6200
6201    // Param is passed by value, moved
6202    pub fn set_deprecated(&mut self, v: bool) {
6203        self.deprecated = ::std::option::Option::Some(v);
6204    }
6205
6206    fn generated_message_descriptor_data() -> crate::reflect::GeneratedMessageDescriptorData {
6207        let mut fields = ::std::vec::Vec::with_capacity(2);
6208        let mut oneofs = ::std::vec::Vec::with_capacity(0);
6209        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
6210            "deprecated",
6211            |m: &EnumValueOptions| { &m.deprecated },
6212            |m: &mut EnumValueOptions| { &mut m.deprecated },
6213        ));
6214        fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
6215            "uninterpreted_option",
6216            |m: &EnumValueOptions| { &m.uninterpreted_option },
6217            |m: &mut EnumValueOptions| { &mut m.uninterpreted_option },
6218        ));
6219        crate::reflect::GeneratedMessageDescriptorData::new_2::<EnumValueOptions>(
6220            "EnumValueOptions",
6221            fields,
6222            oneofs,
6223        )
6224    }
6225}
6226
6227impl crate::Message for EnumValueOptions {
6228    const NAME: &'static str = "EnumValueOptions";
6229
6230    fn is_initialized(&self) -> bool {
6231        for v in &self.uninterpreted_option {
6232            if !v.is_initialized() {
6233                return false;
6234            }
6235        };
6236        true
6237    }
6238
6239    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::Result<()> {
6240        while let Some(tag) = is.read_raw_tag_or_eof()? {
6241            match tag {
6242                8 => {
6243                    self.deprecated = ::std::option::Option::Some(is.read_bool()?);
6244                },
6245                7994 => {
6246                    self.uninterpreted_option.push(is.read_message()?);
6247                },
6248                tag => {
6249                    crate::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
6250                },
6251            };
6252        }
6253        ::std::result::Result::Ok(())
6254    }
6255
6256    // Compute sizes of nested messages
6257    #[allow(unused_variables)]
6258    fn compute_size(&self) -> u64 {
6259        let mut my_size = 0;
6260        if let Some(v) = self.deprecated {
6261            my_size += 1 + 1;
6262        }
6263        for value in &self.uninterpreted_option {
6264            let len = value.compute_size();
6265            my_size += 2 + crate::rt::compute_raw_varint64_size(len) + len;
6266        };
6267        my_size += crate::rt::unknown_fields_size(self.special_fields.unknown_fields());
6268        self.special_fields.cached_size().set(my_size as u32);
6269        my_size
6270    }
6271
6272    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::Result<()> {
6273        if let Some(v) = self.deprecated {
6274            os.write_bool(1, v)?;
6275        }
6276        for v in &self.uninterpreted_option {
6277            crate::rt::write_message_field_with_cached_size(999, v, os)?;
6278        };
6279        os.write_unknown_fields(self.special_fields.unknown_fields())?;
6280        ::std::result::Result::Ok(())
6281    }
6282
6283    fn special_fields(&self) -> &crate::SpecialFields {
6284        &self.special_fields
6285    }
6286
6287    fn mut_special_fields(&mut self) -> &mut crate::SpecialFields {
6288        &mut self.special_fields
6289    }
6290
6291    fn new() -> EnumValueOptions {
6292        EnumValueOptions::new()
6293    }
6294
6295    fn clear(&mut self) {
6296        self.deprecated = ::std::option::Option::None;
6297        self.uninterpreted_option.clear();
6298        self.special_fields.clear();
6299    }
6300
6301    fn default_instance() -> &'static EnumValueOptions {
6302        static instance: EnumValueOptions = EnumValueOptions {
6303            deprecated: ::std::option::Option::None,
6304            uninterpreted_option: ::std::vec::Vec::new(),
6305            special_fields: crate::SpecialFields::new(),
6306        };
6307        &instance
6308    }
6309}
6310
6311impl crate::MessageFull for EnumValueOptions {
6312    fn descriptor() -> crate::reflect::MessageDescriptor {
6313        static descriptor: crate::rt::Lazy<crate::reflect::MessageDescriptor> = crate::rt::Lazy::new();
6314        descriptor.get(|| file_descriptor().message_by_package_relative_name("EnumValueOptions").unwrap()).clone()
6315    }
6316}
6317
6318impl ::std::fmt::Display for EnumValueOptions {
6319    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6320        crate::text_format::fmt(self, f)
6321    }
6322}
6323
6324impl crate::reflect::ProtobufValue for EnumValueOptions {
6325    type RuntimeType = crate::reflect::rt::RuntimeTypeMessage<Self>;
6326}
6327
6328// @@protoc_insertion_point(message:google.protobuf.ServiceOptions)
6329#[derive(PartialEq,Clone,Default,Debug)]
6330pub struct ServiceOptions {
6331    // message fields
6332    ///  Is this service deprecated?
6333    ///  Depending on the target platform, this can emit Deprecated annotations
6334    ///  for the service, or it will be completely ignored; in the very least,
6335    ///  this is a formalization for deprecating services.
6336    // @@protoc_insertion_point(field:google.protobuf.ServiceOptions.deprecated)
6337    pub deprecated: ::std::option::Option<bool>,
6338    ///  The parser stores options it doesn't recognize here. See above.
6339    // @@protoc_insertion_point(field:google.protobuf.ServiceOptions.uninterpreted_option)
6340    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
6341    // special fields
6342    // @@protoc_insertion_point(special_field:google.protobuf.ServiceOptions.special_fields)
6343    pub special_fields: crate::SpecialFields,
6344}
6345
6346impl<'a> ::std::default::Default for &'a ServiceOptions {
6347    fn default() -> &'a ServiceOptions {
6348        <ServiceOptions as crate::Message>::default_instance()
6349    }
6350}
6351
6352impl ServiceOptions {
6353    pub fn new() -> ServiceOptions {
6354        ::std::default::Default::default()
6355    }
6356
6357    // optional bool deprecated = 33;
6358
6359    pub fn deprecated(&self) -> bool {
6360        self.deprecated.unwrap_or(false)
6361    }
6362
6363    pub fn clear_deprecated(&mut self) {
6364        self.deprecated = ::std::option::Option::None;
6365    }
6366
6367    pub fn has_deprecated(&self) -> bool {
6368        self.deprecated.is_some()
6369    }
6370
6371    // Param is passed by value, moved
6372    pub fn set_deprecated(&mut self, v: bool) {
6373        self.deprecated = ::std::option::Option::Some(v);
6374    }
6375
6376    fn generated_message_descriptor_data() -> crate::reflect::GeneratedMessageDescriptorData {
6377        let mut fields = ::std::vec::Vec::with_capacity(2);
6378        let mut oneofs = ::std::vec::Vec::with_capacity(0);
6379        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
6380            "deprecated",
6381            |m: &ServiceOptions| { &m.deprecated },
6382            |m: &mut ServiceOptions| { &mut m.deprecated },
6383        ));
6384        fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
6385            "uninterpreted_option",
6386            |m: &ServiceOptions| { &m.uninterpreted_option },
6387            |m: &mut ServiceOptions| { &mut m.uninterpreted_option },
6388        ));
6389        crate::reflect::GeneratedMessageDescriptorData::new_2::<ServiceOptions>(
6390            "ServiceOptions",
6391            fields,
6392            oneofs,
6393        )
6394    }
6395}
6396
6397impl crate::Message for ServiceOptions {
6398    const NAME: &'static str = "ServiceOptions";
6399
6400    fn is_initialized(&self) -> bool {
6401        for v in &self.uninterpreted_option {
6402            if !v.is_initialized() {
6403                return false;
6404            }
6405        };
6406        true
6407    }
6408
6409    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::Result<()> {
6410        while let Some(tag) = is.read_raw_tag_or_eof()? {
6411            match tag {
6412                264 => {
6413                    self.deprecated = ::std::option::Option::Some(is.read_bool()?);
6414                },
6415                7994 => {
6416                    self.uninterpreted_option.push(is.read_message()?);
6417                },
6418                tag => {
6419                    crate::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
6420                },
6421            };
6422        }
6423        ::std::result::Result::Ok(())
6424    }
6425
6426    // Compute sizes of nested messages
6427    #[allow(unused_variables)]
6428    fn compute_size(&self) -> u64 {
6429        let mut my_size = 0;
6430        if let Some(v) = self.deprecated {
6431            my_size += 2 + 1;
6432        }
6433        for value in &self.uninterpreted_option {
6434            let len = value.compute_size();
6435            my_size += 2 + crate::rt::compute_raw_varint64_size(len) + len;
6436        };
6437        my_size += crate::rt::unknown_fields_size(self.special_fields.unknown_fields());
6438        self.special_fields.cached_size().set(my_size as u32);
6439        my_size
6440    }
6441
6442    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::Result<()> {
6443        if let Some(v) = self.deprecated {
6444            os.write_bool(33, v)?;
6445        }
6446        for v in &self.uninterpreted_option {
6447            crate::rt::write_message_field_with_cached_size(999, v, os)?;
6448        };
6449        os.write_unknown_fields(self.special_fields.unknown_fields())?;
6450        ::std::result::Result::Ok(())
6451    }
6452
6453    fn special_fields(&self) -> &crate::SpecialFields {
6454        &self.special_fields
6455    }
6456
6457    fn mut_special_fields(&mut self) -> &mut crate::SpecialFields {
6458        &mut self.special_fields
6459    }
6460
6461    fn new() -> ServiceOptions {
6462        ServiceOptions::new()
6463    }
6464
6465    fn clear(&mut self) {
6466        self.deprecated = ::std::option::Option::None;
6467        self.uninterpreted_option.clear();
6468        self.special_fields.clear();
6469    }
6470
6471    fn default_instance() -> &'static ServiceOptions {
6472        static instance: ServiceOptions = ServiceOptions {
6473            deprecated: ::std::option::Option::None,
6474            uninterpreted_option: ::std::vec::Vec::new(),
6475            special_fields: crate::SpecialFields::new(),
6476        };
6477        &instance
6478    }
6479}
6480
6481impl crate::MessageFull for ServiceOptions {
6482    fn descriptor() -> crate::reflect::MessageDescriptor {
6483        static descriptor: crate::rt::Lazy<crate::reflect::MessageDescriptor> = crate::rt::Lazy::new();
6484        descriptor.get(|| file_descriptor().message_by_package_relative_name("ServiceOptions").unwrap()).clone()
6485    }
6486}
6487
6488impl ::std::fmt::Display for ServiceOptions {
6489    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6490        crate::text_format::fmt(self, f)
6491    }
6492}
6493
6494impl crate::reflect::ProtobufValue for ServiceOptions {
6495    type RuntimeType = crate::reflect::rt::RuntimeTypeMessage<Self>;
6496}
6497
6498// @@protoc_insertion_point(message:google.protobuf.MethodOptions)
6499#[derive(PartialEq,Clone,Default,Debug)]
6500pub struct MethodOptions {
6501    // message fields
6502    ///  Is this method deprecated?
6503    ///  Depending on the target platform, this can emit Deprecated annotations
6504    ///  for the method, or it will be completely ignored; in the very least,
6505    ///  this is a formalization for deprecating methods.
6506    // @@protoc_insertion_point(field:google.protobuf.MethodOptions.deprecated)
6507    pub deprecated: ::std::option::Option<bool>,
6508    // @@protoc_insertion_point(field:google.protobuf.MethodOptions.idempotency_level)
6509    pub idempotency_level: ::std::option::Option<crate::EnumOrUnknown<method_options::IdempotencyLevel>>,
6510    ///  The parser stores options it doesn't recognize here. See above.
6511    // @@protoc_insertion_point(field:google.protobuf.MethodOptions.uninterpreted_option)
6512    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
6513    // special fields
6514    // @@protoc_insertion_point(special_field:google.protobuf.MethodOptions.special_fields)
6515    pub special_fields: crate::SpecialFields,
6516}
6517
6518impl<'a> ::std::default::Default for &'a MethodOptions {
6519    fn default() -> &'a MethodOptions {
6520        <MethodOptions as crate::Message>::default_instance()
6521    }
6522}
6523
6524impl MethodOptions {
6525    pub fn new() -> MethodOptions {
6526        ::std::default::Default::default()
6527    }
6528
6529    // optional bool deprecated = 33;
6530
6531    pub fn deprecated(&self) -> bool {
6532        self.deprecated.unwrap_or(false)
6533    }
6534
6535    pub fn clear_deprecated(&mut self) {
6536        self.deprecated = ::std::option::Option::None;
6537    }
6538
6539    pub fn has_deprecated(&self) -> bool {
6540        self.deprecated.is_some()
6541    }
6542
6543    // Param is passed by value, moved
6544    pub fn set_deprecated(&mut self, v: bool) {
6545        self.deprecated = ::std::option::Option::Some(v);
6546    }
6547
6548    // optional .google.protobuf.MethodOptions.IdempotencyLevel idempotency_level = 34;
6549
6550    pub fn idempotency_level(&self) -> method_options::IdempotencyLevel {
6551        match self.idempotency_level {
6552            Some(e) => e.enum_value_or(method_options::IdempotencyLevel::IDEMPOTENCY_UNKNOWN),
6553            None => method_options::IdempotencyLevel::IDEMPOTENCY_UNKNOWN,
6554        }
6555    }
6556
6557    pub fn clear_idempotency_level(&mut self) {
6558        self.idempotency_level = ::std::option::Option::None;
6559    }
6560
6561    pub fn has_idempotency_level(&self) -> bool {
6562        self.idempotency_level.is_some()
6563    }
6564
6565    // Param is passed by value, moved
6566    pub fn set_idempotency_level(&mut self, v: method_options::IdempotencyLevel) {
6567        self.idempotency_level = ::std::option::Option::Some(crate::EnumOrUnknown::new(v));
6568    }
6569
6570    fn generated_message_descriptor_data() -> crate::reflect::GeneratedMessageDescriptorData {
6571        let mut fields = ::std::vec::Vec::with_capacity(3);
6572        let mut oneofs = ::std::vec::Vec::with_capacity(0);
6573        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
6574            "deprecated",
6575            |m: &MethodOptions| { &m.deprecated },
6576            |m: &mut MethodOptions| { &mut m.deprecated },
6577        ));
6578        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
6579            "idempotency_level",
6580            |m: &MethodOptions| { &m.idempotency_level },
6581            |m: &mut MethodOptions| { &mut m.idempotency_level },
6582        ));
6583        fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
6584            "uninterpreted_option",
6585            |m: &MethodOptions| { &m.uninterpreted_option },
6586            |m: &mut MethodOptions| { &mut m.uninterpreted_option },
6587        ));
6588        crate::reflect::GeneratedMessageDescriptorData::new_2::<MethodOptions>(
6589            "MethodOptions",
6590            fields,
6591            oneofs,
6592        )
6593    }
6594}
6595
6596impl crate::Message for MethodOptions {
6597    const NAME: &'static str = "MethodOptions";
6598
6599    fn is_initialized(&self) -> bool {
6600        for v in &self.uninterpreted_option {
6601            if !v.is_initialized() {
6602                return false;
6603            }
6604        };
6605        true
6606    }
6607
6608    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::Result<()> {
6609        while let Some(tag) = is.read_raw_tag_or_eof()? {
6610            match tag {
6611                264 => {
6612                    self.deprecated = ::std::option::Option::Some(is.read_bool()?);
6613                },
6614                272 => {
6615                    self.idempotency_level = ::std::option::Option::Some(is.read_enum_or_unknown()?);
6616                },
6617                7994 => {
6618                    self.uninterpreted_option.push(is.read_message()?);
6619                },
6620                tag => {
6621                    crate::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
6622                },
6623            };
6624        }
6625        ::std::result::Result::Ok(())
6626    }
6627
6628    // Compute sizes of nested messages
6629    #[allow(unused_variables)]
6630    fn compute_size(&self) -> u64 {
6631        let mut my_size = 0;
6632        if let Some(v) = self.deprecated {
6633            my_size += 2 + 1;
6634        }
6635        if let Some(v) = self.idempotency_level {
6636            my_size += crate::rt::int32_size(34, v.value());
6637        }
6638        for value in &self.uninterpreted_option {
6639            let len = value.compute_size();
6640            my_size += 2 + crate::rt::compute_raw_varint64_size(len) + len;
6641        };
6642        my_size += crate::rt::unknown_fields_size(self.special_fields.unknown_fields());
6643        self.special_fields.cached_size().set(my_size as u32);
6644        my_size
6645    }
6646
6647    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::Result<()> {
6648        if let Some(v) = self.deprecated {
6649            os.write_bool(33, v)?;
6650        }
6651        if let Some(v) = self.idempotency_level {
6652            os.write_enum(34, crate::EnumOrUnknown::value(&v))?;
6653        }
6654        for v in &self.uninterpreted_option {
6655            crate::rt::write_message_field_with_cached_size(999, v, os)?;
6656        };
6657        os.write_unknown_fields(self.special_fields.unknown_fields())?;
6658        ::std::result::Result::Ok(())
6659    }
6660
6661    fn special_fields(&self) -> &crate::SpecialFields {
6662        &self.special_fields
6663    }
6664
6665    fn mut_special_fields(&mut self) -> &mut crate::SpecialFields {
6666        &mut self.special_fields
6667    }
6668
6669    fn new() -> MethodOptions {
6670        MethodOptions::new()
6671    }
6672
6673    fn clear(&mut self) {
6674        self.deprecated = ::std::option::Option::None;
6675        self.idempotency_level = ::std::option::Option::None;
6676        self.uninterpreted_option.clear();
6677        self.special_fields.clear();
6678    }
6679
6680    fn default_instance() -> &'static MethodOptions {
6681        static instance: MethodOptions = MethodOptions {
6682            deprecated: ::std::option::Option::None,
6683            idempotency_level: ::std::option::Option::None,
6684            uninterpreted_option: ::std::vec::Vec::new(),
6685            special_fields: crate::SpecialFields::new(),
6686        };
6687        &instance
6688    }
6689}
6690
6691impl crate::MessageFull for MethodOptions {
6692    fn descriptor() -> crate::reflect::MessageDescriptor {
6693        static descriptor: crate::rt::Lazy<crate::reflect::MessageDescriptor> = crate::rt::Lazy::new();
6694        descriptor.get(|| file_descriptor().message_by_package_relative_name("MethodOptions").unwrap()).clone()
6695    }
6696}
6697
6698impl ::std::fmt::Display for MethodOptions {
6699    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6700        crate::text_format::fmt(self, f)
6701    }
6702}
6703
6704impl crate::reflect::ProtobufValue for MethodOptions {
6705    type RuntimeType = crate::reflect::rt::RuntimeTypeMessage<Self>;
6706}
6707
6708/// Nested message and enums of message `MethodOptions`
6709pub mod method_options {
6710    ///  Is this method side-effect-free (or safe in HTTP parlance), or idempotent,
6711    ///  or neither? HTTP based RPC implementation may choose GET verb for safe
6712    ///  methods, and PUT verb for idempotent methods instead of the default POST.
6713    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
6714    // @@protoc_insertion_point(enum:google.protobuf.MethodOptions.IdempotencyLevel)
6715    pub enum IdempotencyLevel {
6716        // @@protoc_insertion_point(enum_value:google.protobuf.MethodOptions.IdempotencyLevel.IDEMPOTENCY_UNKNOWN)
6717        IDEMPOTENCY_UNKNOWN = 0,
6718        // @@protoc_insertion_point(enum_value:google.protobuf.MethodOptions.IdempotencyLevel.NO_SIDE_EFFECTS)
6719        NO_SIDE_EFFECTS = 1,
6720        // @@protoc_insertion_point(enum_value:google.protobuf.MethodOptions.IdempotencyLevel.IDEMPOTENT)
6721        IDEMPOTENT = 2,
6722    }
6723
6724    impl crate::Enum for IdempotencyLevel {
6725        const NAME: &'static str = "IdempotencyLevel";
6726
6727        fn value(&self) -> i32 {
6728            *self as i32
6729        }
6730
6731        fn from_i32(value: i32) -> ::std::option::Option<IdempotencyLevel> {
6732            match value {
6733                0 => ::std::option::Option::Some(IdempotencyLevel::IDEMPOTENCY_UNKNOWN),
6734                1 => ::std::option::Option::Some(IdempotencyLevel::NO_SIDE_EFFECTS),
6735                2 => ::std::option::Option::Some(IdempotencyLevel::IDEMPOTENT),
6736                _ => ::std::option::Option::None
6737            }
6738        }
6739
6740        fn from_str(str: &str) -> ::std::option::Option<IdempotencyLevel> {
6741            match str {
6742                "IDEMPOTENCY_UNKNOWN" => ::std::option::Option::Some(IdempotencyLevel::IDEMPOTENCY_UNKNOWN),
6743                "NO_SIDE_EFFECTS" => ::std::option::Option::Some(IdempotencyLevel::NO_SIDE_EFFECTS),
6744                "IDEMPOTENT" => ::std::option::Option::Some(IdempotencyLevel::IDEMPOTENT),
6745                _ => ::std::option::Option::None
6746            }
6747        }
6748
6749        const VALUES: &'static [IdempotencyLevel] = &[
6750            IdempotencyLevel::IDEMPOTENCY_UNKNOWN,
6751            IdempotencyLevel::NO_SIDE_EFFECTS,
6752            IdempotencyLevel::IDEMPOTENT,
6753        ];
6754    }
6755
6756    impl crate::EnumFull for IdempotencyLevel {
6757        fn enum_descriptor() -> crate::reflect::EnumDescriptor {
6758            static descriptor: crate::rt::Lazy<crate::reflect::EnumDescriptor> = crate::rt::Lazy::new();
6759            descriptor.get(|| super::file_descriptor().enum_by_package_relative_name("MethodOptions.IdempotencyLevel").unwrap()).clone()
6760        }
6761
6762        fn descriptor(&self) -> crate::reflect::EnumValueDescriptor {
6763            let index = *self as usize;
6764            Self::enum_descriptor().value_by_index(index)
6765        }
6766    }
6767
6768    impl ::std::default::Default for IdempotencyLevel {
6769        fn default() -> Self {
6770            IdempotencyLevel::IDEMPOTENCY_UNKNOWN
6771        }
6772    }
6773
6774    impl IdempotencyLevel {
6775        pub(in super) fn generated_enum_descriptor_data() -> crate::reflect::GeneratedEnumDescriptorData {
6776            crate::reflect::GeneratedEnumDescriptorData::new::<IdempotencyLevel>("MethodOptions.IdempotencyLevel")
6777        }
6778    }
6779}
6780
6781///  A message representing a option the parser does not recognize. This only
6782///  appears in options protos created by the compiler::Parser class.
6783///  DescriptorPool resolves these when building Descriptor objects. Therefore,
6784///  options protos in descriptor objects (e.g. returned by Descriptor::options(),
6785///  or produced by Descriptor::CopyTo()) will never have UninterpretedOptions
6786///  in them.
6787// @@protoc_insertion_point(message:google.protobuf.UninterpretedOption)
6788#[derive(PartialEq,Clone,Default,Debug)]
6789pub struct UninterpretedOption {
6790    // message fields
6791    // @@protoc_insertion_point(field:google.protobuf.UninterpretedOption.name)
6792    pub name: ::std::vec::Vec<uninterpreted_option::NamePart>,
6793    ///  The value of the uninterpreted option, in whatever type the tokenizer
6794    ///  identified it as during parsing. Exactly one of these should be set.
6795    // @@protoc_insertion_point(field:google.protobuf.UninterpretedOption.identifier_value)
6796    pub identifier_value: ::std::option::Option<::std::string::String>,
6797    // @@protoc_insertion_point(field:google.protobuf.UninterpretedOption.positive_int_value)
6798    pub positive_int_value: ::std::option::Option<u64>,
6799    // @@protoc_insertion_point(field:google.protobuf.UninterpretedOption.negative_int_value)
6800    pub negative_int_value: ::std::option::Option<i64>,
6801    // @@protoc_insertion_point(field:google.protobuf.UninterpretedOption.double_value)
6802    pub double_value: ::std::option::Option<f64>,
6803    // @@protoc_insertion_point(field:google.protobuf.UninterpretedOption.string_value)
6804    pub string_value: ::std::option::Option<::std::vec::Vec<u8>>,
6805    // @@protoc_insertion_point(field:google.protobuf.UninterpretedOption.aggregate_value)
6806    pub aggregate_value: ::std::option::Option<::std::string::String>,
6807    // special fields
6808    // @@protoc_insertion_point(special_field:google.protobuf.UninterpretedOption.special_fields)
6809    pub special_fields: crate::SpecialFields,
6810}
6811
6812impl<'a> ::std::default::Default for &'a UninterpretedOption {
6813    fn default() -> &'a UninterpretedOption {
6814        <UninterpretedOption as crate::Message>::default_instance()
6815    }
6816}
6817
6818impl UninterpretedOption {
6819    pub fn new() -> UninterpretedOption {
6820        ::std::default::Default::default()
6821    }
6822
6823    // optional string identifier_value = 3;
6824
6825    pub fn identifier_value(&self) -> &str {
6826        match self.identifier_value.as_ref() {
6827            Some(v) => v,
6828            None => "",
6829        }
6830    }
6831
6832    pub fn clear_identifier_value(&mut self) {
6833        self.identifier_value = ::std::option::Option::None;
6834    }
6835
6836    pub fn has_identifier_value(&self) -> bool {
6837        self.identifier_value.is_some()
6838    }
6839
6840    // Param is passed by value, moved
6841    pub fn set_identifier_value(&mut self, v: ::std::string::String) {
6842        self.identifier_value = ::std::option::Option::Some(v);
6843    }
6844
6845    // Mutable pointer to the field.
6846    // If field is not initialized, it is initialized with default value first.
6847    pub fn mut_identifier_value(&mut self) -> &mut ::std::string::String {
6848        if self.identifier_value.is_none() {
6849            self.identifier_value = ::std::option::Option::Some(::std::string::String::new());
6850        }
6851        self.identifier_value.as_mut().unwrap()
6852    }
6853
6854    // Take field
6855    pub fn take_identifier_value(&mut self) -> ::std::string::String {
6856        self.identifier_value.take().unwrap_or_else(|| ::std::string::String::new())
6857    }
6858
6859    // optional uint64 positive_int_value = 4;
6860
6861    pub fn positive_int_value(&self) -> u64 {
6862        self.positive_int_value.unwrap_or(0)
6863    }
6864
6865    pub fn clear_positive_int_value(&mut self) {
6866        self.positive_int_value = ::std::option::Option::None;
6867    }
6868
6869    pub fn has_positive_int_value(&self) -> bool {
6870        self.positive_int_value.is_some()
6871    }
6872
6873    // Param is passed by value, moved
6874    pub fn set_positive_int_value(&mut self, v: u64) {
6875        self.positive_int_value = ::std::option::Option::Some(v);
6876    }
6877
6878    // optional int64 negative_int_value = 5;
6879
6880    pub fn negative_int_value(&self) -> i64 {
6881        self.negative_int_value.unwrap_or(0)
6882    }
6883
6884    pub fn clear_negative_int_value(&mut self) {
6885        self.negative_int_value = ::std::option::Option::None;
6886    }
6887
6888    pub fn has_negative_int_value(&self) -> bool {
6889        self.negative_int_value.is_some()
6890    }
6891
6892    // Param is passed by value, moved
6893    pub fn set_negative_int_value(&mut self, v: i64) {
6894        self.negative_int_value = ::std::option::Option::Some(v);
6895    }
6896
6897    // optional double double_value = 6;
6898
6899    pub fn double_value(&self) -> f64 {
6900        self.double_value.unwrap_or(0.)
6901    }
6902
6903    pub fn clear_double_value(&mut self) {
6904        self.double_value = ::std::option::Option::None;
6905    }
6906
6907    pub fn has_double_value(&self) -> bool {
6908        self.double_value.is_some()
6909    }
6910
6911    // Param is passed by value, moved
6912    pub fn set_double_value(&mut self, v: f64) {
6913        self.double_value = ::std::option::Option::Some(v);
6914    }
6915
6916    // optional bytes string_value = 7;
6917
6918    pub fn string_value(&self) -> &[u8] {
6919        match self.string_value.as_ref() {
6920            Some(v) => v,
6921            None => &[],
6922        }
6923    }
6924
6925    pub fn clear_string_value(&mut self) {
6926        self.string_value = ::std::option::Option::None;
6927    }
6928
6929    pub fn has_string_value(&self) -> bool {
6930        self.string_value.is_some()
6931    }
6932
6933    // Param is passed by value, moved
6934    pub fn set_string_value(&mut self, v: ::std::vec::Vec<u8>) {
6935        self.string_value = ::std::option::Option::Some(v);
6936    }
6937
6938    // Mutable pointer to the field.
6939    // If field is not initialized, it is initialized with default value first.
6940    pub fn mut_string_value(&mut self) -> &mut ::std::vec::Vec<u8> {
6941        if self.string_value.is_none() {
6942            self.string_value = ::std::option::Option::Some(::std::vec::Vec::new());
6943        }
6944        self.string_value.as_mut().unwrap()
6945    }
6946
6947    // Take field
6948    pub fn take_string_value(&mut self) -> ::std::vec::Vec<u8> {
6949        self.string_value.take().unwrap_or_else(|| ::std::vec::Vec::new())
6950    }
6951
6952    // optional string aggregate_value = 8;
6953
6954    pub fn aggregate_value(&self) -> &str {
6955        match self.aggregate_value.as_ref() {
6956            Some(v) => v,
6957            None => "",
6958        }
6959    }
6960
6961    pub fn clear_aggregate_value(&mut self) {
6962        self.aggregate_value = ::std::option::Option::None;
6963    }
6964
6965    pub fn has_aggregate_value(&self) -> bool {
6966        self.aggregate_value.is_some()
6967    }
6968
6969    // Param is passed by value, moved
6970    pub fn set_aggregate_value(&mut self, v: ::std::string::String) {
6971        self.aggregate_value = ::std::option::Option::Some(v);
6972    }
6973
6974    // Mutable pointer to the field.
6975    // If field is not initialized, it is initialized with default value first.
6976    pub fn mut_aggregate_value(&mut self) -> &mut ::std::string::String {
6977        if self.aggregate_value.is_none() {
6978            self.aggregate_value = ::std::option::Option::Some(::std::string::String::new());
6979        }
6980        self.aggregate_value.as_mut().unwrap()
6981    }
6982
6983    // Take field
6984    pub fn take_aggregate_value(&mut self) -> ::std::string::String {
6985        self.aggregate_value.take().unwrap_or_else(|| ::std::string::String::new())
6986    }
6987
6988    fn generated_message_descriptor_data() -> crate::reflect::GeneratedMessageDescriptorData {
6989        let mut fields = ::std::vec::Vec::with_capacity(7);
6990        let mut oneofs = ::std::vec::Vec::with_capacity(0);
6991        fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
6992            "name",
6993            |m: &UninterpretedOption| { &m.name },
6994            |m: &mut UninterpretedOption| { &mut m.name },
6995        ));
6996        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
6997            "identifier_value",
6998            |m: &UninterpretedOption| { &m.identifier_value },
6999            |m: &mut UninterpretedOption| { &mut m.identifier_value },
7000        ));
7001        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
7002            "positive_int_value",
7003            |m: &UninterpretedOption| { &m.positive_int_value },
7004            |m: &mut UninterpretedOption| { &mut m.positive_int_value },
7005        ));
7006        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
7007            "negative_int_value",
7008            |m: &UninterpretedOption| { &m.negative_int_value },
7009            |m: &mut UninterpretedOption| { &mut m.negative_int_value },
7010        ));
7011        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
7012            "double_value",
7013            |m: &UninterpretedOption| { &m.double_value },
7014            |m: &mut UninterpretedOption| { &mut m.double_value },
7015        ));
7016        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
7017            "string_value",
7018            |m: &UninterpretedOption| { &m.string_value },
7019            |m: &mut UninterpretedOption| { &mut m.string_value },
7020        ));
7021        fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
7022            "aggregate_value",
7023            |m: &UninterpretedOption| { &m.aggregate_value },
7024            |m: &mut UninterpretedOption| { &mut m.aggregate_value },
7025        ));
7026        crate::reflect::GeneratedMessageDescriptorData::new_2::<UninterpretedOption>(
7027            "UninterpretedOption",
7028            fields,
7029            oneofs,
7030        )
7031    }
7032}
7033
7034impl crate::Message for UninterpretedOption {
7035    const NAME: &'static str = "UninterpretedOption";
7036
7037    fn is_initialized(&self) -> bool {
7038        for v in &self.name {
7039            if !v.is_initialized() {
7040                return false;
7041            }
7042        };
7043        true
7044    }
7045
7046    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::Result<()> {
7047        while let Some(tag) = is.read_raw_tag_or_eof()? {
7048            match tag {
7049                18 => {
7050                    self.name.push(is.read_message()?);
7051                },
7052                26 => {
7053                    self.identifier_value = ::std::option::Option::Some(is.read_string()?);
7054                },
7055                32 => {
7056                    self.positive_int_value = ::std::option::Option::Some(is.read_uint64()?);
7057                },
7058                40 => {
7059                    self.negative_int_value = ::std::option::Option::Some(is.read_int64()?);
7060                },
7061                49 => {
7062                    self.double_value = ::std::option::Option::Some(is.read_double()?);
7063                },
7064                58 => {
7065                    self.string_value = ::std::option::Option::Some(is.read_bytes()?);
7066                },
7067                66 => {
7068                    self.aggregate_value = ::std::option::Option::Some(is.read_string()?);
7069                },
7070                tag => {
7071                    crate::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
7072                },
7073            };
7074        }
7075        ::std::result::Result::Ok(())
7076    }
7077
7078    // Compute sizes of nested messages
7079    #[allow(unused_variables)]
7080    fn compute_size(&self) -> u64 {
7081        let mut my_size = 0;
7082        for value in &self.name {
7083            let len = value.compute_size();
7084            my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len;
7085        };
7086        if let Some(v) = self.identifier_value.as_ref() {
7087            my_size += crate::rt::string_size(3, &v);
7088        }
7089        if let Some(v) = self.positive_int_value {
7090            my_size += crate::rt::uint64_size(4, v);
7091        }
7092        if let Some(v) = self.negative_int_value {
7093            my_size += crate::rt::int64_size(5, v);
7094        }
7095        if let Some(v) = self.double_value {
7096            my_size += 1 + 8;
7097        }
7098        if let Some(v) = self.string_value.as_ref() {
7099            my_size += crate::rt::bytes_size(7, &v);
7100        }
7101        if let Some(v) = self.aggregate_value.as_ref() {
7102            my_size += crate::rt::string_size(8, &v);
7103        }
7104        my_size += crate::rt::unknown_fields_size(self.special_fields.unknown_fields());
7105        self.special_fields.cached_size().set(my_size as u32);
7106        my_size
7107    }
7108
7109    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::Result<()> {
7110        for v in &self.name {
7111            crate::rt::write_message_field_with_cached_size(2, v, os)?;
7112        };
7113        if let Some(v) = self.identifier_value.as_ref() {
7114            os.write_string(3, v)?;
7115        }
7116        if let Some(v) = self.positive_int_value {
7117            os.write_uint64(4, v)?;
7118        }
7119        if let Some(v) = self.negative_int_value {
7120            os.write_int64(5, v)?;
7121        }
7122        if let Some(v) = self.double_value {
7123            os.write_double(6, v)?;
7124        }
7125        if let Some(v) = self.string_value.as_ref() {
7126            os.write_bytes(7, v)?;
7127        }
7128        if let Some(v) = self.aggregate_value.as_ref() {
7129            os.write_string(8, v)?;
7130        }
7131        os.write_unknown_fields(self.special_fields.unknown_fields())?;
7132        ::std::result::Result::Ok(())
7133    }
7134
7135    fn special_fields(&self) -> &crate::SpecialFields {
7136        &self.special_fields
7137    }
7138
7139    fn mut_special_fields(&mut self) -> &mut crate::SpecialFields {
7140        &mut self.special_fields
7141    }
7142
7143    fn new() -> UninterpretedOption {
7144        UninterpretedOption::new()
7145    }
7146
7147    fn clear(&mut self) {
7148        self.name.clear();
7149        self.identifier_value = ::std::option::Option::None;
7150        self.positive_int_value = ::std::option::Option::None;
7151        self.negative_int_value = ::std::option::Option::None;
7152        self.double_value = ::std::option::Option::None;
7153        self.string_value = ::std::option::Option::None;
7154        self.aggregate_value = ::std::option::Option::None;
7155        self.special_fields.clear();
7156    }
7157
7158    fn default_instance() -> &'static UninterpretedOption {
7159        static instance: UninterpretedOption = UninterpretedOption {
7160            name: ::std::vec::Vec::new(),
7161            identifier_value: ::std::option::Option::None,
7162            positive_int_value: ::std::option::Option::None,
7163            negative_int_value: ::std::option::Option::None,
7164            double_value: ::std::option::Option::None,
7165            string_value: ::std::option::Option::None,
7166            aggregate_value: ::std::option::Option::None,
7167            special_fields: crate::SpecialFields::new(),
7168        };
7169        &instance
7170    }
7171}
7172
7173impl crate::MessageFull for UninterpretedOption {
7174    fn descriptor() -> crate::reflect::MessageDescriptor {
7175        static descriptor: crate::rt::Lazy<crate::reflect::MessageDescriptor> = crate::rt::Lazy::new();
7176        descriptor.get(|| file_descriptor().message_by_package_relative_name("UninterpretedOption").unwrap()).clone()
7177    }
7178}
7179
7180impl ::std::fmt::Display for UninterpretedOption {
7181    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7182        crate::text_format::fmt(self, f)
7183    }
7184}
7185
7186impl crate::reflect::ProtobufValue for UninterpretedOption {
7187    type RuntimeType = crate::reflect::rt::RuntimeTypeMessage<Self>;
7188}
7189
7190/// Nested message and enums of message `UninterpretedOption`
7191pub mod uninterpreted_option {
7192    ///  The name of the uninterpreted option.  Each string represents a segment in
7193    ///  a dot-separated name.  is_extension is true iff a segment represents an
7194    ///  extension (denoted with parentheses in options specs in .proto files).
7195    ///  E.g.,{ ["foo", false], ["bar.baz", true], ["qux", false] } represents
7196    ///  "foo.(bar.baz).qux".
7197    // @@protoc_insertion_point(message:google.protobuf.UninterpretedOption.NamePart)
7198    #[derive(PartialEq,Clone,Default,Debug)]
7199    pub struct NamePart {
7200        // message fields
7201        // @@protoc_insertion_point(field:google.protobuf.UninterpretedOption.NamePart.name_part)
7202        pub name_part: ::std::option::Option<::std::string::String>,
7203        // @@protoc_insertion_point(field:google.protobuf.UninterpretedOption.NamePart.is_extension)
7204        pub is_extension: ::std::option::Option<bool>,
7205        // special fields
7206        // @@protoc_insertion_point(special_field:google.protobuf.UninterpretedOption.NamePart.special_fields)
7207        pub special_fields: crate::SpecialFields,
7208    }
7209
7210    impl<'a> ::std::default::Default for &'a NamePart {
7211        fn default() -> &'a NamePart {
7212            <NamePart as crate::Message>::default_instance()
7213        }
7214    }
7215
7216    impl NamePart {
7217        pub fn new() -> NamePart {
7218            ::std::default::Default::default()
7219        }
7220
7221        // required string name_part = 1;
7222
7223        pub fn name_part(&self) -> &str {
7224            match self.name_part.as_ref() {
7225                Some(v) => v,
7226                None => "",
7227            }
7228        }
7229
7230        pub fn clear_name_part(&mut self) {
7231            self.name_part = ::std::option::Option::None;
7232        }
7233
7234        pub fn has_name_part(&self) -> bool {
7235            self.name_part.is_some()
7236        }
7237
7238        // Param is passed by value, moved
7239        pub fn set_name_part(&mut self, v: ::std::string::String) {
7240            self.name_part = ::std::option::Option::Some(v);
7241        }
7242
7243        // Mutable pointer to the field.
7244        // If field is not initialized, it is initialized with default value first.
7245        pub fn mut_name_part(&mut self) -> &mut ::std::string::String {
7246            if self.name_part.is_none() {
7247                self.name_part = ::std::option::Option::Some(::std::string::String::new());
7248            }
7249            self.name_part.as_mut().unwrap()
7250        }
7251
7252        // Take field
7253        pub fn take_name_part(&mut self) -> ::std::string::String {
7254            self.name_part.take().unwrap_or_else(|| ::std::string::String::new())
7255        }
7256
7257        // required bool is_extension = 2;
7258
7259        pub fn is_extension(&self) -> bool {
7260            self.is_extension.unwrap_or(false)
7261        }
7262
7263        pub fn clear_is_extension(&mut self) {
7264            self.is_extension = ::std::option::Option::None;
7265        }
7266
7267        pub fn has_is_extension(&self) -> bool {
7268            self.is_extension.is_some()
7269        }
7270
7271        // Param is passed by value, moved
7272        pub fn set_is_extension(&mut self, v: bool) {
7273            self.is_extension = ::std::option::Option::Some(v);
7274        }
7275
7276        pub(in super) fn generated_message_descriptor_data() -> crate::reflect::GeneratedMessageDescriptorData {
7277            let mut fields = ::std::vec::Vec::with_capacity(2);
7278            let mut oneofs = ::std::vec::Vec::with_capacity(0);
7279            fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
7280                "name_part",
7281                |m: &NamePart| { &m.name_part },
7282                |m: &mut NamePart| { &mut m.name_part },
7283            ));
7284            fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
7285                "is_extension",
7286                |m: &NamePart| { &m.is_extension },
7287                |m: &mut NamePart| { &mut m.is_extension },
7288            ));
7289            crate::reflect::GeneratedMessageDescriptorData::new_2::<NamePart>(
7290                "UninterpretedOption.NamePart",
7291                fields,
7292                oneofs,
7293            )
7294        }
7295    }
7296
7297    impl crate::Message for NamePart {
7298        const NAME: &'static str = "NamePart";
7299
7300        fn is_initialized(&self) -> bool {
7301            if self.name_part.is_none() {
7302                return false;
7303            }
7304            if self.is_extension.is_none() {
7305                return false;
7306            }
7307            true
7308        }
7309
7310        fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::Result<()> {
7311            while let Some(tag) = is.read_raw_tag_or_eof()? {
7312                match tag {
7313                    10 => {
7314                        self.name_part = ::std::option::Option::Some(is.read_string()?);
7315                    },
7316                    16 => {
7317                        self.is_extension = ::std::option::Option::Some(is.read_bool()?);
7318                    },
7319                    tag => {
7320                        crate::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
7321                    },
7322                };
7323            }
7324            ::std::result::Result::Ok(())
7325        }
7326
7327        // Compute sizes of nested messages
7328        #[allow(unused_variables)]
7329        fn compute_size(&self) -> u64 {
7330            let mut my_size = 0;
7331            if let Some(v) = self.name_part.as_ref() {
7332                my_size += crate::rt::string_size(1, &v);
7333            }
7334            if let Some(v) = self.is_extension {
7335                my_size += 1 + 1;
7336            }
7337            my_size += crate::rt::unknown_fields_size(self.special_fields.unknown_fields());
7338            self.special_fields.cached_size().set(my_size as u32);
7339            my_size
7340        }
7341
7342        fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::Result<()> {
7343            if let Some(v) = self.name_part.as_ref() {
7344                os.write_string(1, v)?;
7345            }
7346            if let Some(v) = self.is_extension {
7347                os.write_bool(2, v)?;
7348            }
7349            os.write_unknown_fields(self.special_fields.unknown_fields())?;
7350            ::std::result::Result::Ok(())
7351        }
7352
7353        fn special_fields(&self) -> &crate::SpecialFields {
7354            &self.special_fields
7355        }
7356
7357        fn mut_special_fields(&mut self) -> &mut crate::SpecialFields {
7358            &mut self.special_fields
7359        }
7360
7361        fn new() -> NamePart {
7362            NamePart::new()
7363        }
7364
7365        fn clear(&mut self) {
7366            self.name_part = ::std::option::Option::None;
7367            self.is_extension = ::std::option::Option::None;
7368            self.special_fields.clear();
7369        }
7370
7371        fn default_instance() -> &'static NamePart {
7372            static instance: NamePart = NamePart {
7373                name_part: ::std::option::Option::None,
7374                is_extension: ::std::option::Option::None,
7375                special_fields: crate::SpecialFields::new(),
7376            };
7377            &instance
7378        }
7379    }
7380
7381    impl crate::MessageFull for NamePart {
7382        fn descriptor() -> crate::reflect::MessageDescriptor {
7383            static descriptor: crate::rt::Lazy<crate::reflect::MessageDescriptor> = crate::rt::Lazy::new();
7384            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("UninterpretedOption.NamePart").unwrap()).clone()
7385        }
7386    }
7387
7388    impl ::std::fmt::Display for NamePart {
7389        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7390            crate::text_format::fmt(self, f)
7391        }
7392    }
7393
7394    impl crate::reflect::ProtobufValue for NamePart {
7395        type RuntimeType = crate::reflect::rt::RuntimeTypeMessage<Self>;
7396    }
7397}
7398
7399///  Encapsulates information about the original source file from which a
7400///  FileDescriptorProto was generated.
7401// @@protoc_insertion_point(message:google.protobuf.SourceCodeInfo)
7402#[derive(PartialEq,Clone,Default,Debug)]
7403pub struct SourceCodeInfo {
7404    // message fields
7405    // @@protoc_insertion_point(field:google.protobuf.SourceCodeInfo.location)
7406    pub location: ::std::vec::Vec<source_code_info::Location>,
7407    // special fields
7408    // @@protoc_insertion_point(special_field:google.protobuf.SourceCodeInfo.special_fields)
7409    pub special_fields: crate::SpecialFields,
7410}
7411
7412impl<'a> ::std::default::Default for &'a SourceCodeInfo {
7413    fn default() -> &'a SourceCodeInfo {
7414        <SourceCodeInfo as crate::Message>::default_instance()
7415    }
7416}
7417
7418impl SourceCodeInfo {
7419    pub fn new() -> SourceCodeInfo {
7420        ::std::default::Default::default()
7421    }
7422
7423    fn generated_message_descriptor_data() -> crate::reflect::GeneratedMessageDescriptorData {
7424        let mut fields = ::std::vec::Vec::with_capacity(1);
7425        let mut oneofs = ::std::vec::Vec::with_capacity(0);
7426        fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
7427            "location",
7428            |m: &SourceCodeInfo| { &m.location },
7429            |m: &mut SourceCodeInfo| { &mut m.location },
7430        ));
7431        crate::reflect::GeneratedMessageDescriptorData::new_2::<SourceCodeInfo>(
7432            "SourceCodeInfo",
7433            fields,
7434            oneofs,
7435        )
7436    }
7437}
7438
7439impl crate::Message for SourceCodeInfo {
7440    const NAME: &'static str = "SourceCodeInfo";
7441
7442    fn is_initialized(&self) -> bool {
7443        true
7444    }
7445
7446    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::Result<()> {
7447        while let Some(tag) = is.read_raw_tag_or_eof()? {
7448            match tag {
7449                10 => {
7450                    self.location.push(is.read_message()?);
7451                },
7452                tag => {
7453                    crate::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
7454                },
7455            };
7456        }
7457        ::std::result::Result::Ok(())
7458    }
7459
7460    // Compute sizes of nested messages
7461    #[allow(unused_variables)]
7462    fn compute_size(&self) -> u64 {
7463        let mut my_size = 0;
7464        for value in &self.location {
7465            let len = value.compute_size();
7466            my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len;
7467        };
7468        my_size += crate::rt::unknown_fields_size(self.special_fields.unknown_fields());
7469        self.special_fields.cached_size().set(my_size as u32);
7470        my_size
7471    }
7472
7473    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::Result<()> {
7474        for v in &self.location {
7475            crate::rt::write_message_field_with_cached_size(1, v, os)?;
7476        };
7477        os.write_unknown_fields(self.special_fields.unknown_fields())?;
7478        ::std::result::Result::Ok(())
7479    }
7480
7481    fn special_fields(&self) -> &crate::SpecialFields {
7482        &self.special_fields
7483    }
7484
7485    fn mut_special_fields(&mut self) -> &mut crate::SpecialFields {
7486        &mut self.special_fields
7487    }
7488
7489    fn new() -> SourceCodeInfo {
7490        SourceCodeInfo::new()
7491    }
7492
7493    fn clear(&mut self) {
7494        self.location.clear();
7495        self.special_fields.clear();
7496    }
7497
7498    fn default_instance() -> &'static SourceCodeInfo {
7499        static instance: SourceCodeInfo = SourceCodeInfo {
7500            location: ::std::vec::Vec::new(),
7501            special_fields: crate::SpecialFields::new(),
7502        };
7503        &instance
7504    }
7505}
7506
7507impl crate::MessageFull for SourceCodeInfo {
7508    fn descriptor() -> crate::reflect::MessageDescriptor {
7509        static descriptor: crate::rt::Lazy<crate::reflect::MessageDescriptor> = crate::rt::Lazy::new();
7510        descriptor.get(|| file_descriptor().message_by_package_relative_name("SourceCodeInfo").unwrap()).clone()
7511    }
7512}
7513
7514impl ::std::fmt::Display for SourceCodeInfo {
7515    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7516        crate::text_format::fmt(self, f)
7517    }
7518}
7519
7520impl crate::reflect::ProtobufValue for SourceCodeInfo {
7521    type RuntimeType = crate::reflect::rt::RuntimeTypeMessage<Self>;
7522}
7523
7524/// Nested message and enums of message `SourceCodeInfo`
7525pub mod source_code_info {
7526    // @@protoc_insertion_point(message:google.protobuf.SourceCodeInfo.Location)
7527    #[derive(PartialEq,Clone,Default,Debug)]
7528    pub struct Location {
7529        // message fields
7530        // @@protoc_insertion_point(field:google.protobuf.SourceCodeInfo.Location.path)
7531        pub path: ::std::vec::Vec<i32>,
7532        ///  Always has exactly three or four elements: start line, start column,
7533        ///  end line (optional, otherwise assumed same as start line), end column.
7534        ///  These are packed into a single field for efficiency.  Note that line
7535        ///  and column numbers are zero-based -- typically you will want to add
7536        ///  1 to each before displaying to a user.
7537        // @@protoc_insertion_point(field:google.protobuf.SourceCodeInfo.Location.span)
7538        pub span: ::std::vec::Vec<i32>,
7539        // @@protoc_insertion_point(field:google.protobuf.SourceCodeInfo.Location.leading_comments)
7540        pub leading_comments: ::std::option::Option<::std::string::String>,
7541        // @@protoc_insertion_point(field:google.protobuf.SourceCodeInfo.Location.trailing_comments)
7542        pub trailing_comments: ::std::option::Option<::std::string::String>,
7543        // @@protoc_insertion_point(field:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
7544        pub leading_detached_comments: ::std::vec::Vec<::std::string::String>,
7545        // special fields
7546        // @@protoc_insertion_point(special_field:google.protobuf.SourceCodeInfo.Location.special_fields)
7547        pub special_fields: crate::SpecialFields,
7548    }
7549
7550    impl<'a> ::std::default::Default for &'a Location {
7551        fn default() -> &'a Location {
7552            <Location as crate::Message>::default_instance()
7553        }
7554    }
7555
7556    impl Location {
7557        pub fn new() -> Location {
7558            ::std::default::Default::default()
7559        }
7560
7561        // optional string leading_comments = 3;
7562
7563        pub fn leading_comments(&self) -> &str {
7564            match self.leading_comments.as_ref() {
7565                Some(v) => v,
7566                None => "",
7567            }
7568        }
7569
7570        pub fn clear_leading_comments(&mut self) {
7571            self.leading_comments = ::std::option::Option::None;
7572        }
7573
7574        pub fn has_leading_comments(&self) -> bool {
7575            self.leading_comments.is_some()
7576        }
7577
7578        // Param is passed by value, moved
7579        pub fn set_leading_comments(&mut self, v: ::std::string::String) {
7580            self.leading_comments = ::std::option::Option::Some(v);
7581        }
7582
7583        // Mutable pointer to the field.
7584        // If field is not initialized, it is initialized with default value first.
7585        pub fn mut_leading_comments(&mut self) -> &mut ::std::string::String {
7586            if self.leading_comments.is_none() {
7587                self.leading_comments = ::std::option::Option::Some(::std::string::String::new());
7588            }
7589            self.leading_comments.as_mut().unwrap()
7590        }
7591
7592        // Take field
7593        pub fn take_leading_comments(&mut self) -> ::std::string::String {
7594            self.leading_comments.take().unwrap_or_else(|| ::std::string::String::new())
7595        }
7596
7597        // optional string trailing_comments = 4;
7598
7599        pub fn trailing_comments(&self) -> &str {
7600            match self.trailing_comments.as_ref() {
7601                Some(v) => v,
7602                None => "",
7603            }
7604        }
7605
7606        pub fn clear_trailing_comments(&mut self) {
7607            self.trailing_comments = ::std::option::Option::None;
7608        }
7609
7610        pub fn has_trailing_comments(&self) -> bool {
7611            self.trailing_comments.is_some()
7612        }
7613
7614        // Param is passed by value, moved
7615        pub fn set_trailing_comments(&mut self, v: ::std::string::String) {
7616            self.trailing_comments = ::std::option::Option::Some(v);
7617        }
7618
7619        // Mutable pointer to the field.
7620        // If field is not initialized, it is initialized with default value first.
7621        pub fn mut_trailing_comments(&mut self) -> &mut ::std::string::String {
7622            if self.trailing_comments.is_none() {
7623                self.trailing_comments = ::std::option::Option::Some(::std::string::String::new());
7624            }
7625            self.trailing_comments.as_mut().unwrap()
7626        }
7627
7628        // Take field
7629        pub fn take_trailing_comments(&mut self) -> ::std::string::String {
7630            self.trailing_comments.take().unwrap_or_else(|| ::std::string::String::new())
7631        }
7632
7633        pub(in super) fn generated_message_descriptor_data() -> crate::reflect::GeneratedMessageDescriptorData {
7634            let mut fields = ::std::vec::Vec::with_capacity(5);
7635            let mut oneofs = ::std::vec::Vec::with_capacity(0);
7636            fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
7637                "path",
7638                |m: &Location| { &m.path },
7639                |m: &mut Location| { &mut m.path },
7640            ));
7641            fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
7642                "span",
7643                |m: &Location| { &m.span },
7644                |m: &mut Location| { &mut m.span },
7645            ));
7646            fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
7647                "leading_comments",
7648                |m: &Location| { &m.leading_comments },
7649                |m: &mut Location| { &mut m.leading_comments },
7650            ));
7651            fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
7652                "trailing_comments",
7653                |m: &Location| { &m.trailing_comments },
7654                |m: &mut Location| { &mut m.trailing_comments },
7655            ));
7656            fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
7657                "leading_detached_comments",
7658                |m: &Location| { &m.leading_detached_comments },
7659                |m: &mut Location| { &mut m.leading_detached_comments },
7660            ));
7661            crate::reflect::GeneratedMessageDescriptorData::new_2::<Location>(
7662                "SourceCodeInfo.Location",
7663                fields,
7664                oneofs,
7665            )
7666        }
7667    }
7668
7669    impl crate::Message for Location {
7670        const NAME: &'static str = "Location";
7671
7672        fn is_initialized(&self) -> bool {
7673            true
7674        }
7675
7676        fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::Result<()> {
7677            while let Some(tag) = is.read_raw_tag_or_eof()? {
7678                match tag {
7679                    10 => {
7680                        is.read_repeated_packed_int32_into(&mut self.path)?;
7681                    },
7682                    8 => {
7683                        self.path.push(is.read_int32()?);
7684                    },
7685                    18 => {
7686                        is.read_repeated_packed_int32_into(&mut self.span)?;
7687                    },
7688                    16 => {
7689                        self.span.push(is.read_int32()?);
7690                    },
7691                    26 => {
7692                        self.leading_comments = ::std::option::Option::Some(is.read_string()?);
7693                    },
7694                    34 => {
7695                        self.trailing_comments = ::std::option::Option::Some(is.read_string()?);
7696                    },
7697                    50 => {
7698                        self.leading_detached_comments.push(is.read_string()?);
7699                    },
7700                    tag => {
7701                        crate::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
7702                    },
7703                };
7704            }
7705            ::std::result::Result::Ok(())
7706        }
7707
7708        // Compute sizes of nested messages
7709        #[allow(unused_variables)]
7710        fn compute_size(&self) -> u64 {
7711            let mut my_size = 0;
7712            my_size += crate::rt::vec_packed_int32_size(1, &self.path);
7713            my_size += crate::rt::vec_packed_int32_size(2, &self.span);
7714            if let Some(v) = self.leading_comments.as_ref() {
7715                my_size += crate::rt::string_size(3, &v);
7716            }
7717            if let Some(v) = self.trailing_comments.as_ref() {
7718                my_size += crate::rt::string_size(4, &v);
7719            }
7720            for value in &self.leading_detached_comments {
7721                my_size += crate::rt::string_size(6, &value);
7722            };
7723            my_size += crate::rt::unknown_fields_size(self.special_fields.unknown_fields());
7724            self.special_fields.cached_size().set(my_size as u32);
7725            my_size
7726        }
7727
7728        fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::Result<()> {
7729            os.write_repeated_packed_int32(1, &self.path)?;
7730            os.write_repeated_packed_int32(2, &self.span)?;
7731            if let Some(v) = self.leading_comments.as_ref() {
7732                os.write_string(3, v)?;
7733            }
7734            if let Some(v) = self.trailing_comments.as_ref() {
7735                os.write_string(4, v)?;
7736            }
7737            for v in &self.leading_detached_comments {
7738                os.write_string(6, &v)?;
7739            };
7740            os.write_unknown_fields(self.special_fields.unknown_fields())?;
7741            ::std::result::Result::Ok(())
7742        }
7743
7744        fn special_fields(&self) -> &crate::SpecialFields {
7745            &self.special_fields
7746        }
7747
7748        fn mut_special_fields(&mut self) -> &mut crate::SpecialFields {
7749            &mut self.special_fields
7750        }
7751
7752        fn new() -> Location {
7753            Location::new()
7754        }
7755
7756        fn clear(&mut self) {
7757            self.path.clear();
7758            self.span.clear();
7759            self.leading_comments = ::std::option::Option::None;
7760            self.trailing_comments = ::std::option::Option::None;
7761            self.leading_detached_comments.clear();
7762            self.special_fields.clear();
7763        }
7764
7765        fn default_instance() -> &'static Location {
7766            static instance: Location = Location {
7767                path: ::std::vec::Vec::new(),
7768                span: ::std::vec::Vec::new(),
7769                leading_comments: ::std::option::Option::None,
7770                trailing_comments: ::std::option::Option::None,
7771                leading_detached_comments: ::std::vec::Vec::new(),
7772                special_fields: crate::SpecialFields::new(),
7773            };
7774            &instance
7775        }
7776    }
7777
7778    impl crate::MessageFull for Location {
7779        fn descriptor() -> crate::reflect::MessageDescriptor {
7780            static descriptor: crate::rt::Lazy<crate::reflect::MessageDescriptor> = crate::rt::Lazy::new();
7781            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("SourceCodeInfo.Location").unwrap()).clone()
7782        }
7783    }
7784
7785    impl ::std::fmt::Display for Location {
7786        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7787            crate::text_format::fmt(self, f)
7788        }
7789    }
7790
7791    impl crate::reflect::ProtobufValue for Location {
7792        type RuntimeType = crate::reflect::rt::RuntimeTypeMessage<Self>;
7793    }
7794}
7795
7796///  Describes the relationship between generated code and its original source
7797///  file. A GeneratedCodeInfo message is associated with only one generated
7798///  source file, but may contain references to different source .proto files.
7799// @@protoc_insertion_point(message:google.protobuf.GeneratedCodeInfo)
7800#[derive(PartialEq,Clone,Default,Debug)]
7801pub struct GeneratedCodeInfo {
7802    // message fields
7803    ///  An Annotation connects some span of text in generated code to an element
7804    ///  of its generating .proto file.
7805    // @@protoc_insertion_point(field:google.protobuf.GeneratedCodeInfo.annotation)
7806    pub annotation: ::std::vec::Vec<generated_code_info::Annotation>,
7807    // special fields
7808    // @@protoc_insertion_point(special_field:google.protobuf.GeneratedCodeInfo.special_fields)
7809    pub special_fields: crate::SpecialFields,
7810}
7811
7812impl<'a> ::std::default::Default for &'a GeneratedCodeInfo {
7813    fn default() -> &'a GeneratedCodeInfo {
7814        <GeneratedCodeInfo as crate::Message>::default_instance()
7815    }
7816}
7817
7818impl GeneratedCodeInfo {
7819    pub fn new() -> GeneratedCodeInfo {
7820        ::std::default::Default::default()
7821    }
7822
7823    fn generated_message_descriptor_data() -> crate::reflect::GeneratedMessageDescriptorData {
7824        let mut fields = ::std::vec::Vec::with_capacity(1);
7825        let mut oneofs = ::std::vec::Vec::with_capacity(0);
7826        fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
7827            "annotation",
7828            |m: &GeneratedCodeInfo| { &m.annotation },
7829            |m: &mut GeneratedCodeInfo| { &mut m.annotation },
7830        ));
7831        crate::reflect::GeneratedMessageDescriptorData::new_2::<GeneratedCodeInfo>(
7832            "GeneratedCodeInfo",
7833            fields,
7834            oneofs,
7835        )
7836    }
7837}
7838
7839impl crate::Message for GeneratedCodeInfo {
7840    const NAME: &'static str = "GeneratedCodeInfo";
7841
7842    fn is_initialized(&self) -> bool {
7843        true
7844    }
7845
7846    fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::Result<()> {
7847        while let Some(tag) = is.read_raw_tag_or_eof()? {
7848            match tag {
7849                10 => {
7850                    self.annotation.push(is.read_message()?);
7851                },
7852                tag => {
7853                    crate::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
7854                },
7855            };
7856        }
7857        ::std::result::Result::Ok(())
7858    }
7859
7860    // Compute sizes of nested messages
7861    #[allow(unused_variables)]
7862    fn compute_size(&self) -> u64 {
7863        let mut my_size = 0;
7864        for value in &self.annotation {
7865            let len = value.compute_size();
7866            my_size += 1 + crate::rt::compute_raw_varint64_size(len) + len;
7867        };
7868        my_size += crate::rt::unknown_fields_size(self.special_fields.unknown_fields());
7869        self.special_fields.cached_size().set(my_size as u32);
7870        my_size
7871    }
7872
7873    fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::Result<()> {
7874        for v in &self.annotation {
7875            crate::rt::write_message_field_with_cached_size(1, v, os)?;
7876        };
7877        os.write_unknown_fields(self.special_fields.unknown_fields())?;
7878        ::std::result::Result::Ok(())
7879    }
7880
7881    fn special_fields(&self) -> &crate::SpecialFields {
7882        &self.special_fields
7883    }
7884
7885    fn mut_special_fields(&mut self) -> &mut crate::SpecialFields {
7886        &mut self.special_fields
7887    }
7888
7889    fn new() -> GeneratedCodeInfo {
7890        GeneratedCodeInfo::new()
7891    }
7892
7893    fn clear(&mut self) {
7894        self.annotation.clear();
7895        self.special_fields.clear();
7896    }
7897
7898    fn default_instance() -> &'static GeneratedCodeInfo {
7899        static instance: GeneratedCodeInfo = GeneratedCodeInfo {
7900            annotation: ::std::vec::Vec::new(),
7901            special_fields: crate::SpecialFields::new(),
7902        };
7903        &instance
7904    }
7905}
7906
7907impl crate::MessageFull for GeneratedCodeInfo {
7908    fn descriptor() -> crate::reflect::MessageDescriptor {
7909        static descriptor: crate::rt::Lazy<crate::reflect::MessageDescriptor> = crate::rt::Lazy::new();
7910        descriptor.get(|| file_descriptor().message_by_package_relative_name("GeneratedCodeInfo").unwrap()).clone()
7911    }
7912}
7913
7914impl ::std::fmt::Display for GeneratedCodeInfo {
7915    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7916        crate::text_format::fmt(self, f)
7917    }
7918}
7919
7920impl crate::reflect::ProtobufValue for GeneratedCodeInfo {
7921    type RuntimeType = crate::reflect::rt::RuntimeTypeMessage<Self>;
7922}
7923
7924/// Nested message and enums of message `GeneratedCodeInfo`
7925pub mod generated_code_info {
7926    // @@protoc_insertion_point(message:google.protobuf.GeneratedCodeInfo.Annotation)
7927    #[derive(PartialEq,Clone,Default,Debug)]
7928    pub struct Annotation {
7929        // message fields
7930        ///  Identifies the element in the original source .proto file. This field
7931        ///  is formatted the same as SourceCodeInfo.Location.path.
7932        // @@protoc_insertion_point(field:google.protobuf.GeneratedCodeInfo.Annotation.path)
7933        pub path: ::std::vec::Vec<i32>,
7934        ///  Identifies the filesystem path to the original source .proto.
7935        // @@protoc_insertion_point(field:google.protobuf.GeneratedCodeInfo.Annotation.source_file)
7936        pub source_file: ::std::option::Option<::std::string::String>,
7937        ///  Identifies the starting offset in bytes in the generated code
7938        ///  that relates to the identified object.
7939        // @@protoc_insertion_point(field:google.protobuf.GeneratedCodeInfo.Annotation.begin)
7940        pub begin: ::std::option::Option<i32>,
7941        ///  Identifies the ending offset in bytes in the generated code that
7942        ///  relates to the identified offset. The end offset should be one past
7943        ///  the last relevant byte (so the length of the text = end - begin).
7944        // @@protoc_insertion_point(field:google.protobuf.GeneratedCodeInfo.Annotation.end)
7945        pub end: ::std::option::Option<i32>,
7946        // special fields
7947        // @@protoc_insertion_point(special_field:google.protobuf.GeneratedCodeInfo.Annotation.special_fields)
7948        pub special_fields: crate::SpecialFields,
7949    }
7950
7951    impl<'a> ::std::default::Default for &'a Annotation {
7952        fn default() -> &'a Annotation {
7953            <Annotation as crate::Message>::default_instance()
7954        }
7955    }
7956
7957    impl Annotation {
7958        pub fn new() -> Annotation {
7959            ::std::default::Default::default()
7960        }
7961
7962        // optional string source_file = 2;
7963
7964        pub fn source_file(&self) -> &str {
7965            match self.source_file.as_ref() {
7966                Some(v) => v,
7967                None => "",
7968            }
7969        }
7970
7971        pub fn clear_source_file(&mut self) {
7972            self.source_file = ::std::option::Option::None;
7973        }
7974
7975        pub fn has_source_file(&self) -> bool {
7976            self.source_file.is_some()
7977        }
7978
7979        // Param is passed by value, moved
7980        pub fn set_source_file(&mut self, v: ::std::string::String) {
7981            self.source_file = ::std::option::Option::Some(v);
7982        }
7983
7984        // Mutable pointer to the field.
7985        // If field is not initialized, it is initialized with default value first.
7986        pub fn mut_source_file(&mut self) -> &mut ::std::string::String {
7987            if self.source_file.is_none() {
7988                self.source_file = ::std::option::Option::Some(::std::string::String::new());
7989            }
7990            self.source_file.as_mut().unwrap()
7991        }
7992
7993        // Take field
7994        pub fn take_source_file(&mut self) -> ::std::string::String {
7995            self.source_file.take().unwrap_or_else(|| ::std::string::String::new())
7996        }
7997
7998        // optional int32 begin = 3;
7999
8000        pub fn begin(&self) -> i32 {
8001            self.begin.unwrap_or(0)
8002        }
8003
8004        pub fn clear_begin(&mut self) {
8005            self.begin = ::std::option::Option::None;
8006        }
8007
8008        pub fn has_begin(&self) -> bool {
8009            self.begin.is_some()
8010        }
8011
8012        // Param is passed by value, moved
8013        pub fn set_begin(&mut self, v: i32) {
8014            self.begin = ::std::option::Option::Some(v);
8015        }
8016
8017        // optional int32 end = 4;
8018
8019        pub fn end(&self) -> i32 {
8020            self.end.unwrap_or(0)
8021        }
8022
8023        pub fn clear_end(&mut self) {
8024            self.end = ::std::option::Option::None;
8025        }
8026
8027        pub fn has_end(&self) -> bool {
8028            self.end.is_some()
8029        }
8030
8031        // Param is passed by value, moved
8032        pub fn set_end(&mut self, v: i32) {
8033            self.end = ::std::option::Option::Some(v);
8034        }
8035
8036        pub(in super) fn generated_message_descriptor_data() -> crate::reflect::GeneratedMessageDescriptorData {
8037            let mut fields = ::std::vec::Vec::with_capacity(4);
8038            let mut oneofs = ::std::vec::Vec::with_capacity(0);
8039            fields.push(crate::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
8040                "path",
8041                |m: &Annotation| { &m.path },
8042                |m: &mut Annotation| { &mut m.path },
8043            ));
8044            fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
8045                "source_file",
8046                |m: &Annotation| { &m.source_file },
8047                |m: &mut Annotation| { &mut m.source_file },
8048            ));
8049            fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
8050                "begin",
8051                |m: &Annotation| { &m.begin },
8052                |m: &mut Annotation| { &mut m.begin },
8053            ));
8054            fields.push(crate::reflect::rt::v2::make_option_accessor::<_, _>(
8055                "end",
8056                |m: &Annotation| { &m.end },
8057                |m: &mut Annotation| { &mut m.end },
8058            ));
8059            crate::reflect::GeneratedMessageDescriptorData::new_2::<Annotation>(
8060                "GeneratedCodeInfo.Annotation",
8061                fields,
8062                oneofs,
8063            )
8064        }
8065    }
8066
8067    impl crate::Message for Annotation {
8068        const NAME: &'static str = "Annotation";
8069
8070        fn is_initialized(&self) -> bool {
8071            true
8072        }
8073
8074        fn merge_from(&mut self, is: &mut crate::CodedInputStream<'_>) -> crate::Result<()> {
8075            while let Some(tag) = is.read_raw_tag_or_eof()? {
8076                match tag {
8077                    10 => {
8078                        is.read_repeated_packed_int32_into(&mut self.path)?;
8079                    },
8080                    8 => {
8081                        self.path.push(is.read_int32()?);
8082                    },
8083                    18 => {
8084                        self.source_file = ::std::option::Option::Some(is.read_string()?);
8085                    },
8086                    24 => {
8087                        self.begin = ::std::option::Option::Some(is.read_int32()?);
8088                    },
8089                    32 => {
8090                        self.end = ::std::option::Option::Some(is.read_int32()?);
8091                    },
8092                    tag => {
8093                        crate::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
8094                    },
8095                };
8096            }
8097            ::std::result::Result::Ok(())
8098        }
8099
8100        // Compute sizes of nested messages
8101        #[allow(unused_variables)]
8102        fn compute_size(&self) -> u64 {
8103            let mut my_size = 0;
8104            my_size += crate::rt::vec_packed_int32_size(1, &self.path);
8105            if let Some(v) = self.source_file.as_ref() {
8106                my_size += crate::rt::string_size(2, &v);
8107            }
8108            if let Some(v) = self.begin {
8109                my_size += crate::rt::int32_size(3, v);
8110            }
8111            if let Some(v) = self.end {
8112                my_size += crate::rt::int32_size(4, v);
8113            }
8114            my_size += crate::rt::unknown_fields_size(self.special_fields.unknown_fields());
8115            self.special_fields.cached_size().set(my_size as u32);
8116            my_size
8117        }
8118
8119        fn write_to_with_cached_sizes(&self, os: &mut crate::CodedOutputStream<'_>) -> crate::Result<()> {
8120            os.write_repeated_packed_int32(1, &self.path)?;
8121            if let Some(v) = self.source_file.as_ref() {
8122                os.write_string(2, v)?;
8123            }
8124            if let Some(v) = self.begin {
8125                os.write_int32(3, v)?;
8126            }
8127            if let Some(v) = self.end {
8128                os.write_int32(4, v)?;
8129            }
8130            os.write_unknown_fields(self.special_fields.unknown_fields())?;
8131            ::std::result::Result::Ok(())
8132        }
8133
8134        fn special_fields(&self) -> &crate::SpecialFields {
8135            &self.special_fields
8136        }
8137
8138        fn mut_special_fields(&mut self) -> &mut crate::SpecialFields {
8139            &mut self.special_fields
8140        }
8141
8142        fn new() -> Annotation {
8143            Annotation::new()
8144        }
8145
8146        fn clear(&mut self) {
8147            self.path.clear();
8148            self.source_file = ::std::option::Option::None;
8149            self.begin = ::std::option::Option::None;
8150            self.end = ::std::option::Option::None;
8151            self.special_fields.clear();
8152        }
8153
8154        fn default_instance() -> &'static Annotation {
8155            static instance: Annotation = Annotation {
8156                path: ::std::vec::Vec::new(),
8157                source_file: ::std::option::Option::None,
8158                begin: ::std::option::Option::None,
8159                end: ::std::option::Option::None,
8160                special_fields: crate::SpecialFields::new(),
8161            };
8162            &instance
8163        }
8164    }
8165
8166    impl crate::MessageFull for Annotation {
8167        fn descriptor() -> crate::reflect::MessageDescriptor {
8168            static descriptor: crate::rt::Lazy<crate::reflect::MessageDescriptor> = crate::rt::Lazy::new();
8169            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("GeneratedCodeInfo.Annotation").unwrap()).clone()
8170        }
8171    }
8172
8173    impl ::std::fmt::Display for Annotation {
8174        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8175            crate::text_format::fmt(self, f)
8176        }
8177    }
8178
8179    impl crate::reflect::ProtobufValue for Annotation {
8180        type RuntimeType = crate::reflect::rt::RuntimeTypeMessage<Self>;
8181    }
8182}
8183
8184static file_descriptor_proto_data: &'static [u8] = b"\
8185    \n\x20google/protobuf/descriptor.proto\x12\x0fgoogle.protobuf\"M\n\x11Fi\
8186    leDescriptorSet\x128\n\x04file\x18\x01\x20\x03(\x0b2$.google.protobuf.Fi\
8187    leDescriptorProtoR\x04file\"\xe4\x04\n\x13FileDescriptorProto\x12\x12\n\
8188    \x04name\x18\x01\x20\x01(\tR\x04name\x12\x18\n\x07package\x18\x02\x20\
8189    \x01(\tR\x07package\x12\x1e\n\ndependency\x18\x03\x20\x03(\tR\ndependenc\
8190    y\x12+\n\x11public_dependency\x18\n\x20\x03(\x05R\x10publicDependency\
8191    \x12'\n\x0fweak_dependency\x18\x0b\x20\x03(\x05R\x0eweakDependency\x12C\
8192    \n\x0cmessage_type\x18\x04\x20\x03(\x0b2\x20.google.protobuf.DescriptorP\
8193    rotoR\x0bmessageType\x12A\n\tenum_type\x18\x05\x20\x03(\x0b2$.google.pro\
8194    tobuf.EnumDescriptorProtoR\x08enumType\x12A\n\x07service\x18\x06\x20\x03\
8195    (\x0b2'.google.protobuf.ServiceDescriptorProtoR\x07service\x12C\n\texten\
8196    sion\x18\x07\x20\x03(\x0b2%.google.protobuf.FieldDescriptorProtoR\texten\
8197    sion\x126\n\x07options\x18\x08\x20\x01(\x0b2\x1c.google.protobuf.FileOpt\
8198    ionsR\x07options\x12I\n\x10source_code_info\x18\t\x20\x01(\x0b2\x1f.goog\
8199    le.protobuf.SourceCodeInfoR\x0esourceCodeInfo\x12\x16\n\x06syntax\x18\
8200    \x0c\x20\x01(\tR\x06syntax\"\xb9\x06\n\x0fDescriptorProto\x12\x12\n\x04n\
8201    ame\x18\x01\x20\x01(\tR\x04name\x12;\n\x05field\x18\x02\x20\x03(\x0b2%.g\
8202    oogle.protobuf.FieldDescriptorProtoR\x05field\x12C\n\textension\x18\x06\
8203    \x20\x03(\x0b2%.google.protobuf.FieldDescriptorProtoR\textension\x12A\n\
8204    \x0bnested_type\x18\x03\x20\x03(\x0b2\x20.google.protobuf.DescriptorProt\
8205    oR\nnestedType\x12A\n\tenum_type\x18\x04\x20\x03(\x0b2$.google.protobuf.\
8206    EnumDescriptorProtoR\x08enumType\x12X\n\x0fextension_range\x18\x05\x20\
8207    \x03(\x0b2/.google.protobuf.DescriptorProto.ExtensionRangeR\x0eextension\
8208    Range\x12D\n\noneof_decl\x18\x08\x20\x03(\x0b2%.google.protobuf.OneofDes\
8209    criptorProtoR\toneofDecl\x129\n\x07options\x18\x07\x20\x01(\x0b2\x1f.goo\
8210    gle.protobuf.MessageOptionsR\x07options\x12U\n\x0ereserved_range\x18\t\
8211    \x20\x03(\x0b2..google.protobuf.DescriptorProto.ReservedRangeR\rreserved\
8212    Range\x12#\n\rreserved_name\x18\n\x20\x03(\tR\x0creservedName\x1az\n\x0e\
8213    ExtensionRange\x12\x14\n\x05start\x18\x01\x20\x01(\x05R\x05start\x12\x10\
8214    \n\x03end\x18\x02\x20\x01(\x05R\x03end\x12@\n\x07options\x18\x03\x20\x01\
8215    (\x0b2&.google.protobuf.ExtensionRangeOptionsR\x07options\x1a7\n\rReserv\
8216    edRange\x12\x14\n\x05start\x18\x01\x20\x01(\x05R\x05start\x12\x10\n\x03e\
8217    nd\x18\x02\x20\x01(\x05R\x03end\"|\n\x15ExtensionRangeOptions\x12X\n\x14\
8218    uninterpreted_option\x18\xe7\x07\x20\x03(\x0b2$.google.protobuf.Uninterp\
8219    retedOptionR\x13uninterpretedOption*\t\x08\xe8\x07\x10\x80\x80\x80\x80\
8220    \x02\"\xc1\x06\n\x14FieldDescriptorProto\x12\x12\n\x04name\x18\x01\x20\
8221    \x01(\tR\x04name\x12\x16\n\x06number\x18\x03\x20\x01(\x05R\x06number\x12\
8222    A\n\x05label\x18\x04\x20\x01(\x0e2+.google.protobuf.FieldDescriptorProto\
8223    .LabelR\x05label\x12>\n\x04type\x18\x05\x20\x01(\x0e2*.google.protobuf.F\
8224    ieldDescriptorProto.TypeR\x04type\x12\x1b\n\ttype_name\x18\x06\x20\x01(\
8225    \tR\x08typeName\x12\x1a\n\x08extendee\x18\x02\x20\x01(\tR\x08extendee\
8226    \x12#\n\rdefault_value\x18\x07\x20\x01(\tR\x0cdefaultValue\x12\x1f\n\x0b\
8227    oneof_index\x18\t\x20\x01(\x05R\noneofIndex\x12\x1b\n\tjson_name\x18\n\
8228    \x20\x01(\tR\x08jsonName\x127\n\x07options\x18\x08\x20\x01(\x0b2\x1d.goo\
8229    gle.protobuf.FieldOptionsR\x07options\x12'\n\x0fproto3_optional\x18\x11\
8230    \x20\x01(\x08R\x0eproto3Optional\"\xb6\x02\n\x04Type\x12\x0f\n\x0bTYPE_D\
8231    OUBLE\x10\x01\x12\x0e\n\nTYPE_FLOAT\x10\x02\x12\x0e\n\nTYPE_INT64\x10\
8232    \x03\x12\x0f\n\x0bTYPE_UINT64\x10\x04\x12\x0e\n\nTYPE_INT32\x10\x05\x12\
8233    \x10\n\x0cTYPE_FIXED64\x10\x06\x12\x10\n\x0cTYPE_FIXED32\x10\x07\x12\r\n\
8234    \tTYPE_BOOL\x10\x08\x12\x0f\n\x0bTYPE_STRING\x10\t\x12\x0e\n\nTYPE_GROUP\
8235    \x10\n\x12\x10\n\x0cTYPE_MESSAGE\x10\x0b\x12\x0e\n\nTYPE_BYTES\x10\x0c\
8236    \x12\x0f\n\x0bTYPE_UINT32\x10\r\x12\r\n\tTYPE_ENUM\x10\x0e\x12\x11\n\rTY\
8237    PE_SFIXED32\x10\x0f\x12\x11\n\rTYPE_SFIXED64\x10\x10\x12\x0f\n\x0bTYPE_S\
8238    INT32\x10\x11\x12\x0f\n\x0bTYPE_SINT64\x10\x12\"C\n\x05Label\x12\x12\n\
8239    \x0eLABEL_OPTIONAL\x10\x01\x12\x12\n\x0eLABEL_REQUIRED\x10\x02\x12\x12\n\
8240    \x0eLABEL_REPEATED\x10\x03\"c\n\x14OneofDescriptorProto\x12\x12\n\x04nam\
8241    e\x18\x01\x20\x01(\tR\x04name\x127\n\x07options\x18\x02\x20\x01(\x0b2\
8242    \x1d.google.protobuf.OneofOptionsR\x07options\"\xe3\x02\n\x13EnumDescrip\
8243    torProto\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x12?\n\x05value\
8244    \x18\x02\x20\x03(\x0b2).google.protobuf.EnumValueDescriptorProtoR\x05val\
8245    ue\x126\n\x07options\x18\x03\x20\x01(\x0b2\x1c.google.protobuf.EnumOptio\
8246    nsR\x07options\x12]\n\x0ereserved_range\x18\x04\x20\x03(\x0b26.google.pr\
8247    otobuf.EnumDescriptorProto.EnumReservedRangeR\rreservedRange\x12#\n\rres\
8248    erved_name\x18\x05\x20\x03(\tR\x0creservedName\x1a;\n\x11EnumReservedRan\
8249    ge\x12\x14\n\x05start\x18\x01\x20\x01(\x05R\x05start\x12\x10\n\x03end\
8250    \x18\x02\x20\x01(\x05R\x03end\"\x83\x01\n\x18EnumValueDescriptorProto\
8251    \x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x12\x16\n\x06number\x18\
8252    \x02\x20\x01(\x05R\x06number\x12;\n\x07options\x18\x03\x20\x01(\x0b2!.go\
8253    ogle.protobuf.EnumValueOptionsR\x07options\"\xa7\x01\n\x16ServiceDescrip\
8254    torProto\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x12>\n\x06method\
8255    \x18\x02\x20\x03(\x0b2&.google.protobuf.MethodDescriptorProtoR\x06method\
8256    \x129\n\x07options\x18\x03\x20\x01(\x0b2\x1f.google.protobuf.ServiceOpti\
8257    onsR\x07options\"\x89\x02\n\x15MethodDescriptorProto\x12\x12\n\x04name\
8258    \x18\x01\x20\x01(\tR\x04name\x12\x1d\n\ninput_type\x18\x02\x20\x01(\tR\t\
8259    inputType\x12\x1f\n\x0boutput_type\x18\x03\x20\x01(\tR\noutputType\x128\
8260    \n\x07options\x18\x04\x20\x01(\x0b2\x1e.google.protobuf.MethodOptionsR\
8261    \x07options\x120\n\x10client_streaming\x18\x05\x20\x01(\x08:\x05falseR\
8262    \x0fclientStreaming\x120\n\x10server_streaming\x18\x06\x20\x01(\x08:\x05\
8263    falseR\x0fserverStreaming\"\x91\t\n\x0bFileOptions\x12!\n\x0cjava_packag\
8264    e\x18\x01\x20\x01(\tR\x0bjavaPackage\x120\n\x14java_outer_classname\x18\
8265    \x08\x20\x01(\tR\x12javaOuterClassname\x125\n\x13java_multiple_files\x18\
8266    \n\x20\x01(\x08:\x05falseR\x11javaMultipleFiles\x12D\n\x1djava_generate_\
8267    equals_and_hash\x18\x14\x20\x01(\x08R\x19javaGenerateEqualsAndHashB\x02\
8268    \x18\x01\x12:\n\x16java_string_check_utf8\x18\x1b\x20\x01(\x08:\x05false\
8269    R\x13javaStringCheckUtf8\x12S\n\x0coptimize_for\x18\t\x20\x01(\x0e2).goo\
8270    gle.protobuf.FileOptions.OptimizeMode:\x05SPEEDR\x0boptimizeFor\x12\x1d\
8271    \n\ngo_package\x18\x0b\x20\x01(\tR\tgoPackage\x125\n\x13cc_generic_servi\
8272    ces\x18\x10\x20\x01(\x08:\x05falseR\x11ccGenericServices\x129\n\x15java_\
8273    generic_services\x18\x11\x20\x01(\x08:\x05falseR\x13javaGenericServices\
8274    \x125\n\x13py_generic_services\x18\x12\x20\x01(\x08:\x05falseR\x11pyGene\
8275    ricServices\x127\n\x14php_generic_services\x18*\x20\x01(\x08:\x05falseR\
8276    \x12phpGenericServices\x12%\n\ndeprecated\x18\x17\x20\x01(\x08:\x05false\
8277    R\ndeprecated\x12.\n\x10cc_enable_arenas\x18\x1f\x20\x01(\x08:\x04trueR\
8278    \x0eccEnableArenas\x12*\n\x11objc_class_prefix\x18$\x20\x01(\tR\x0fobjcC\
8279    lassPrefix\x12)\n\x10csharp_namespace\x18%\x20\x01(\tR\x0fcsharpNamespac\
8280    e\x12!\n\x0cswift_prefix\x18'\x20\x01(\tR\x0bswiftPrefix\x12(\n\x10php_c\
8281    lass_prefix\x18(\x20\x01(\tR\x0ephpClassPrefix\x12#\n\rphp_namespace\x18\
8282    )\x20\x01(\tR\x0cphpNamespace\x124\n\x16php_metadata_namespace\x18,\x20\
8283    \x01(\tR\x14phpMetadataNamespace\x12!\n\x0cruby_package\x18-\x20\x01(\tR\
8284    \x0brubyPackage\x12X\n\x14uninterpreted_option\x18\xe7\x07\x20\x03(\x0b2\
8285    $.google.protobuf.UninterpretedOptionR\x13uninterpretedOption\":\n\x0cOp\
8286    timizeMode\x12\t\n\x05SPEED\x10\x01\x12\r\n\tCODE_SIZE\x10\x02\x12\x10\n\
8287    \x0cLITE_RUNTIME\x10\x03*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02J\x04\x08\
8288    &\x10'\"\xe3\x02\n\x0eMessageOptions\x12<\n\x17message_set_wire_format\
8289    \x18\x01\x20\x01(\x08:\x05falseR\x14messageSetWireFormat\x12L\n\x1fno_st\
8290    andard_descriptor_accessor\x18\x02\x20\x01(\x08:\x05falseR\x1cnoStandard\
8291    DescriptorAccessor\x12%\n\ndeprecated\x18\x03\x20\x01(\x08:\x05falseR\nd\
8292    eprecated\x12\x1b\n\tmap_entry\x18\x07\x20\x01(\x08R\x08mapEntry\x12X\n\
8293    \x14uninterpreted_option\x18\xe7\x07\x20\x03(\x0b2$.google.protobuf.Unin\
8294    terpretedOptionR\x13uninterpretedOption*\t\x08\xe8\x07\x10\x80\x80\x80\
8295    \x80\x02J\x04\x08\x04\x10\x05J\x04\x08\x05\x10\x06J\x04\x08\x06\x10\x07J\
8296    \x04\x08\x08\x10\tJ\x04\x08\t\x10\n\"\xe2\x03\n\x0cFieldOptions\x12A\n\
8297    \x05ctype\x18\x01\x20\x01(\x0e2#.google.protobuf.FieldOptions.CType:\x06\
8298    STRINGR\x05ctype\x12\x16\n\x06packed\x18\x02\x20\x01(\x08R\x06packed\x12\
8299    G\n\x06jstype\x18\x06\x20\x01(\x0e2$.google.protobuf.FieldOptions.JSType\
8300    :\tJS_NORMALR\x06jstype\x12\x19\n\x04lazy\x18\x05\x20\x01(\x08:\x05false\
8301    R\x04lazy\x12%\n\ndeprecated\x18\x03\x20\x01(\x08:\x05falseR\ndeprecated\
8302    \x12\x19\n\x04weak\x18\n\x20\x01(\x08:\x05falseR\x04weak\x12X\n\x14unint\
8303    erpreted_option\x18\xe7\x07\x20\x03(\x0b2$.google.protobuf.Uninterpreted\
8304    OptionR\x13uninterpretedOption\"/\n\x05CType\x12\n\n\x06STRING\x10\0\x12\
8305    \x08\n\x04CORD\x10\x01\x12\x10\n\x0cSTRING_PIECE\x10\x02\"5\n\x06JSType\
8306    \x12\r\n\tJS_NORMAL\x10\0\x12\r\n\tJS_STRING\x10\x01\x12\r\n\tJS_NUMBER\
8307    \x10\x02*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02J\x04\x08\x04\x10\x05\"s\
8308    \n\x0cOneofOptions\x12X\n\x14uninterpreted_option\x18\xe7\x07\x20\x03(\
8309    \x0b2$.google.protobuf.UninterpretedOptionR\x13uninterpretedOption*\t\
8310    \x08\xe8\x07\x10\x80\x80\x80\x80\x02\"\xc0\x01\n\x0bEnumOptions\x12\x1f\
8311    \n\x0ballow_alias\x18\x02\x20\x01(\x08R\nallowAlias\x12%\n\ndeprecated\
8312    \x18\x03\x20\x01(\x08:\x05falseR\ndeprecated\x12X\n\x14uninterpreted_opt\
8313    ion\x18\xe7\x07\x20\x03(\x0b2$.google.protobuf.UninterpretedOptionR\x13u\
8314    ninterpretedOption*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02J\x04\x08\x05\
8315    \x10\x06\"\x9e\x01\n\x10EnumValueOptions\x12%\n\ndeprecated\x18\x01\x20\
8316    \x01(\x08:\x05falseR\ndeprecated\x12X\n\x14uninterpreted_option\x18\xe7\
8317    \x07\x20\x03(\x0b2$.google.protobuf.UninterpretedOptionR\x13uninterprete\
8318    dOption*\t\x08\xe8\x07\x10\x80\x80\x80\x80\x02\"\x9c\x01\n\x0eServiceOpt\
8319    ions\x12%\n\ndeprecated\x18!\x20\x01(\x08:\x05falseR\ndeprecated\x12X\n\
8320    \x14uninterpreted_option\x18\xe7\x07\x20\x03(\x0b2$.google.protobuf.Unin\
8321    terpretedOptionR\x13uninterpretedOption*\t\x08\xe8\x07\x10\x80\x80\x80\
8322    \x80\x02\"\xe0\x02\n\rMethodOptions\x12%\n\ndeprecated\x18!\x20\x01(\x08\
8323    :\x05falseR\ndeprecated\x12q\n\x11idempotency_level\x18\"\x20\x01(\x0e2/\
8324    .google.protobuf.MethodOptions.IdempotencyLevel:\x13IDEMPOTENCY_UNKNOWNR\
8325    \x10idempotencyLevel\x12X\n\x14uninterpreted_option\x18\xe7\x07\x20\x03(\
8326    \x0b2$.google.protobuf.UninterpretedOptionR\x13uninterpretedOption\"P\n\
8327    \x10IdempotencyLevel\x12\x17\n\x13IDEMPOTENCY_UNKNOWN\x10\0\x12\x13\n\
8328    \x0fNO_SIDE_EFFECTS\x10\x01\x12\x0e\n\nIDEMPOTENT\x10\x02*\t\x08\xe8\x07\
8329    \x10\x80\x80\x80\x80\x02\"\x9a\x03\n\x13UninterpretedOption\x12A\n\x04na\
8330    me\x18\x02\x20\x03(\x0b2-.google.protobuf.UninterpretedOption.NamePartR\
8331    \x04name\x12)\n\x10identifier_value\x18\x03\x20\x01(\tR\x0fidentifierVal\
8332    ue\x12,\n\x12positive_int_value\x18\x04\x20\x01(\x04R\x10positiveIntValu\
8333    e\x12,\n\x12negative_int_value\x18\x05\x20\x01(\x03R\x10negativeIntValue\
8334    \x12!\n\x0cdouble_value\x18\x06\x20\x01(\x01R\x0bdoubleValue\x12!\n\x0cs\
8335    tring_value\x18\x07\x20\x01(\x0cR\x0bstringValue\x12'\n\x0faggregate_val\
8336    ue\x18\x08\x20\x01(\tR\x0eaggregateValue\x1aJ\n\x08NamePart\x12\x1b\n\tn\
8337    ame_part\x18\x01\x20\x02(\tR\x08namePart\x12!\n\x0cis_extension\x18\x02\
8338    \x20\x02(\x08R\x0bisExtension\"\xa7\x02\n\x0eSourceCodeInfo\x12D\n\x08lo\
8339    cation\x18\x01\x20\x03(\x0b2(.google.protobuf.SourceCodeInfo.LocationR\
8340    \x08location\x1a\xce\x01\n\x08Location\x12\x16\n\x04path\x18\x01\x20\x03\
8341    (\x05R\x04pathB\x02\x10\x01\x12\x16\n\x04span\x18\x02\x20\x03(\x05R\x04s\
8342    panB\x02\x10\x01\x12)\n\x10leading_comments\x18\x03\x20\x01(\tR\x0fleadi\
8343    ngComments\x12+\n\x11trailing_comments\x18\x04\x20\x01(\tR\x10trailingCo\
8344    mments\x12:\n\x19leading_detached_comments\x18\x06\x20\x03(\tR\x17leadin\
8345    gDetachedComments\"\xd1\x01\n\x11GeneratedCodeInfo\x12M\n\nannotation\
8346    \x18\x01\x20\x03(\x0b2-.google.protobuf.GeneratedCodeInfo.AnnotationR\na\
8347    nnotation\x1am\n\nAnnotation\x12\x16\n\x04path\x18\x01\x20\x03(\x05R\x04\
8348    pathB\x02\x10\x01\x12\x1f\n\x0bsource_file\x18\x02\x20\x01(\tR\nsourceFi\
8349    le\x12\x14\n\x05begin\x18\x03\x20\x01(\x05R\x05begin\x12\x10\n\x03end\
8350    \x18\x04\x20\x01(\x05R\x03endB~\n\x13com.google.protobufB\x10DescriptorP\
8351    rotosH\x01Z-google.golang.org/protobuf/types/descriptorpb\xf8\x01\x01\
8352    \xa2\x02\x03GPB\xaa\x02\x1aGoogle.Protobuf.ReflectionJ\x82\xca\x02\n\x07\
8353    \x12\x05'\0\x8e\x07\x01\n\xaa\x0f\n\x01\x0c\x12\x03'\0\x122\xc1\x0c\x20P\
8354    rotocol\x20Buffers\x20-\x20Google's\x20data\x20interchange\x20format\n\
8355    \x20Copyright\x202008\x20Google\x20Inc.\x20\x20All\x20rights\x20reserved\
8356    .\n\x20https://developers.google.com/protocol-buffers/\n\n\x20Redistribu\
8357    tion\x20and\x20use\x20in\x20source\x20and\x20binary\x20forms,\x20with\
8358    \x20or\x20without\n\x20modification,\x20are\x20permitted\x20provided\x20\
8359    that\x20the\x20following\x20conditions\x20are\n\x20met:\n\n\x20\x20\x20\
8360    \x20\x20*\x20Redistributions\x20of\x20source\x20code\x20must\x20retain\
8361    \x20the\x20above\x20copyright\n\x20notice,\x20this\x20list\x20of\x20cond\
8362    itions\x20and\x20the\x20following\x20disclaimer.\n\x20\x20\x20\x20\x20*\
8363    \x20Redistributions\x20in\x20binary\x20form\x20must\x20reproduce\x20the\
8364    \x20above\n\x20copyright\x20notice,\x20this\x20list\x20of\x20conditions\
8365    \x20and\x20the\x20following\x20disclaimer\n\x20in\x20the\x20documentatio\
8366    n\x20and/or\x20other\x20materials\x20provided\x20with\x20the\n\x20distri\
8367    bution.\n\x20\x20\x20\x20\x20*\x20Neither\x20the\x20name\x20of\x20Google\
8368    \x20Inc.\x20nor\x20the\x20names\x20of\x20its\n\x20contributors\x20may\
8369    \x20be\x20used\x20to\x20endorse\x20or\x20promote\x20products\x20derived\
8370    \x20from\n\x20this\x20software\x20without\x20specific\x20prior\x20writte\
8371    n\x20permission.\n\n\x20THIS\x20SOFTWARE\x20IS\x20PROVIDED\x20BY\x20THE\
8372    \x20COPYRIGHT\x20HOLDERS\x20AND\x20CONTRIBUTORS\n\x20\"AS\x20IS\"\x20AND\
8373    \x20ANY\x20EXPRESS\x20OR\x20IMPLIED\x20WARRANTIES,\x20INCLUDING,\x20BUT\
8374    \x20NOT\n\x20LIMITED\x20TO,\x20THE\x20IMPLIED\x20WARRANTIES\x20OF\x20MER\
8375    CHANTABILITY\x20AND\x20FITNESS\x20FOR\n\x20A\x20PARTICULAR\x20PURPOSE\
8376    \x20ARE\x20DISCLAIMED.\x20IN\x20NO\x20EVENT\x20SHALL\x20THE\x20COPYRIGHT\
8377    \n\x20OWNER\x20OR\x20CONTRIBUTORS\x20BE\x20LIABLE\x20FOR\x20ANY\x20DIREC\
8378    T,\x20INDIRECT,\x20INCIDENTAL,\n\x20SPECIAL,\x20EXEMPLARY,\x20OR\x20CONS\
8379    EQUENTIAL\x20DAMAGES\x20(INCLUDING,\x20BUT\x20NOT\n\x20LIMITED\x20TO,\
8380    \x20PROCUREMENT\x20OF\x20SUBSTITUTE\x20GOODS\x20OR\x20SERVICES;\x20LOSS\
8381    \x20OF\x20USE,\n\x20DATA,\x20OR\x20PROFITS;\x20OR\x20BUSINESS\x20INTERRU\
8382    PTION)\x20HOWEVER\x20CAUSED\x20AND\x20ON\x20ANY\n\x20THEORY\x20OF\x20LIA\
8383    BILITY,\x20WHETHER\x20IN\x20CONTRACT,\x20STRICT\x20LIABILITY,\x20OR\x20T\
8384    ORT\n\x20(INCLUDING\x20NEGLIGENCE\x20OR\x20OTHERWISE)\x20ARISING\x20IN\
8385    \x20ANY\x20WAY\x20OUT\x20OF\x20THE\x20USE\n\x20OF\x20THIS\x20SOFTWARE,\
8386    \x20EVEN\x20IF\x20ADVISED\x20OF\x20THE\x20POSSIBILITY\x20OF\x20SUCH\x20D\
8387    AMAGE.\n2\xdb\x02\x20Author:\x20kenton@google.com\x20(Kenton\x20Varda)\n\
8388    \x20\x20Based\x20on\x20original\x20Protocol\x20Buffers\x20design\x20by\n\
8389    \x20\x20Sanjay\x20Ghemawat,\x20Jeff\x20Dean,\x20and\x20others.\n\n\x20Th\
8390    e\x20messages\x20in\x20this\x20file\x20describe\x20the\x20definitions\
8391    \x20found\x20in\x20.proto\x20files.\n\x20A\x20valid\x20.proto\x20file\
8392    \x20can\x20be\x20translated\x20directly\x20to\x20a\x20FileDescriptorProt\
8393    o\n\x20without\x20any\x20other\x20information\x20(e.g.\x20without\x20rea\
8394    ding\x20its\x20imports).\n\n\x08\n\x01\x02\x12\x03)\0\x18\n\x08\n\x01\
8395    \x08\x12\x03+\0D\n\t\n\x02\x08\x0b\x12\x03+\0D\n\x08\n\x01\x08\x12\x03,\
8396    \0,\n\t\n\x02\x08\x01\x12\x03,\0,\n\x08\n\x01\x08\x12\x03-\01\n\t\n\x02\
8397    \x08\x08\x12\x03-\01\n\x08\n\x01\x08\x12\x03.\07\n\t\n\x02\x08%\x12\x03.\
8398    \07\n\x08\n\x01\x08\x12\x03/\0!\n\t\n\x02\x08$\x12\x03/\0!\n\x08\n\x01\
8399    \x08\x12\x030\0\x1f\n\t\n\x02\x08\x1f\x12\x030\0\x1f\n\x08\n\x01\x08\x12\
8400    \x034\0\x1c\n\x7f\n\x02\x08\t\x12\x034\0\x1c\x1at\x20descriptor.proto\
8401    \x20must\x20be\x20optimized\x20for\x20speed\x20because\x20reflection-bas\
8402    ed\n\x20algorithms\x20don't\x20work\x20during\x20bootstrapping.\n\nj\n\
8403    \x02\x04\0\x12\x048\0:\x01\x1a^\x20The\x20protocol\x20compiler\x20can\
8404    \x20output\x20a\x20FileDescriptorSet\x20containing\x20the\x20.proto\n\
8405    \x20files\x20it\x20parses.\n\n\n\n\x03\x04\0\x01\x12\x038\x08\x19\n\x0b\
8406    \n\x04\x04\0\x02\0\x12\x039\x02(\n\x0c\n\x05\x04\0\x02\0\x04\x12\x039\
8407    \x02\n\n\x0c\n\x05\x04\0\x02\0\x06\x12\x039\x0b\x1e\n\x0c\n\x05\x04\0\
8408    \x02\0\x01\x12\x039\x1f#\n\x0c\n\x05\x04\0\x02\0\x03\x12\x039&'\n/\n\x02\
8409    \x04\x01\x12\x04=\0Z\x01\x1a#\x20Describes\x20a\x20complete\x20.proto\
8410    \x20file.\n\n\n\n\x03\x04\x01\x01\x12\x03=\x08\x1b\n9\n\x04\x04\x01\x02\
8411    \0\x12\x03>\x02\x1b\",\x20file\x20name,\x20relative\x20to\x20root\x20of\
8412    \x20source\x20tree\n\n\x0c\n\x05\x04\x01\x02\0\x04\x12\x03>\x02\n\n\x0c\
8413    \n\x05\x04\x01\x02\0\x05\x12\x03>\x0b\x11\n\x0c\n\x05\x04\x01\x02\0\x01\
8414    \x12\x03>\x12\x16\n\x0c\n\x05\x04\x01\x02\0\x03\x12\x03>\x19\x1a\n*\n\
8415    \x04\x04\x01\x02\x01\x12\x03?\x02\x1e\"\x1d\x20e.g.\x20\"foo\",\x20\"foo\
8416    .bar\",\x20etc.\n\n\x0c\n\x05\x04\x01\x02\x01\x04\x12\x03?\x02\n\n\x0c\n\
8417    \x05\x04\x01\x02\x01\x05\x12\x03?\x0b\x11\n\x0c\n\x05\x04\x01\x02\x01\
8418    \x01\x12\x03?\x12\x19\n\x0c\n\x05\x04\x01\x02\x01\x03\x12\x03?\x1c\x1d\n\
8419    4\n\x04\x04\x01\x02\x02\x12\x03B\x02!\x1a'\x20Names\x20of\x20files\x20im\
8420    ported\x20by\x20this\x20file.\n\n\x0c\n\x05\x04\x01\x02\x02\x04\x12\x03B\
8421    \x02\n\n\x0c\n\x05\x04\x01\x02\x02\x05\x12\x03B\x0b\x11\n\x0c\n\x05\x04\
8422    \x01\x02\x02\x01\x12\x03B\x12\x1c\n\x0c\n\x05\x04\x01\x02\x02\x03\x12\
8423    \x03B\x1f\x20\nQ\n\x04\x04\x01\x02\x03\x12\x03D\x02(\x1aD\x20Indexes\x20\
8424    of\x20the\x20public\x20imported\x20files\x20in\x20the\x20dependency\x20l\
8425    ist\x20above.\n\n\x0c\n\x05\x04\x01\x02\x03\x04\x12\x03D\x02\n\n\x0c\n\
8426    \x05\x04\x01\x02\x03\x05\x12\x03D\x0b\x10\n\x0c\n\x05\x04\x01\x02\x03\
8427    \x01\x12\x03D\x11\"\n\x0c\n\x05\x04\x01\x02\x03\x03\x12\x03D%'\nz\n\x04\
8428    \x04\x01\x02\x04\x12\x03G\x02&\x1am\x20Indexes\x20of\x20the\x20weak\x20i\
8429    mported\x20files\x20in\x20the\x20dependency\x20list.\n\x20For\x20Google-\
8430    internal\x20migration\x20only.\x20Do\x20not\x20use.\n\n\x0c\n\x05\x04\
8431    \x01\x02\x04\x04\x12\x03G\x02\n\n\x0c\n\x05\x04\x01\x02\x04\x05\x12\x03G\
8432    \x0b\x10\n\x0c\n\x05\x04\x01\x02\x04\x01\x12\x03G\x11\x20\n\x0c\n\x05\
8433    \x04\x01\x02\x04\x03\x12\x03G#%\n6\n\x04\x04\x01\x02\x05\x12\x03J\x02,\
8434    \x1a)\x20All\x20top-level\x20definitions\x20in\x20this\x20file.\n\n\x0c\
8435    \n\x05\x04\x01\x02\x05\x04\x12\x03J\x02\n\n\x0c\n\x05\x04\x01\x02\x05\
8436    \x06\x12\x03J\x0b\x1a\n\x0c\n\x05\x04\x01\x02\x05\x01\x12\x03J\x1b'\n\
8437    \x0c\n\x05\x04\x01\x02\x05\x03\x12\x03J*+\n\x0b\n\x04\x04\x01\x02\x06\
8438    \x12\x03K\x02-\n\x0c\n\x05\x04\x01\x02\x06\x04\x12\x03K\x02\n\n\x0c\n\
8439    \x05\x04\x01\x02\x06\x06\x12\x03K\x0b\x1e\n\x0c\n\x05\x04\x01\x02\x06\
8440    \x01\x12\x03K\x1f(\n\x0c\n\x05\x04\x01\x02\x06\x03\x12\x03K+,\n\x0b\n\
8441    \x04\x04\x01\x02\x07\x12\x03L\x02.\n\x0c\n\x05\x04\x01\x02\x07\x04\x12\
8442    \x03L\x02\n\n\x0c\n\x05\x04\x01\x02\x07\x06\x12\x03L\x0b!\n\x0c\n\x05\
8443    \x04\x01\x02\x07\x01\x12\x03L\")\n\x0c\n\x05\x04\x01\x02\x07\x03\x12\x03\
8444    L,-\n\x0b\n\x04\x04\x01\x02\x08\x12\x03M\x02.\n\x0c\n\x05\x04\x01\x02\
8445    \x08\x04\x12\x03M\x02\n\n\x0c\n\x05\x04\x01\x02\x08\x06\x12\x03M\x0b\x1f\
8446    \n\x0c\n\x05\x04\x01\x02\x08\x01\x12\x03M\x20)\n\x0c\n\x05\x04\x01\x02\
8447    \x08\x03\x12\x03M,-\n\x0b\n\x04\x04\x01\x02\t\x12\x03O\x02#\n\x0c\n\x05\
8448    \x04\x01\x02\t\x04\x12\x03O\x02\n\n\x0c\n\x05\x04\x01\x02\t\x06\x12\x03O\
8449    \x0b\x16\n\x0c\n\x05\x04\x01\x02\t\x01\x12\x03O\x17\x1e\n\x0c\n\x05\x04\
8450    \x01\x02\t\x03\x12\x03O!\"\n\xf4\x01\n\x04\x04\x01\x02\n\x12\x03U\x02/\
8451    \x1a\xe6\x01\x20This\x20field\x20contains\x20optional\x20information\x20\
8452    about\x20the\x20original\x20source\x20code.\n\x20You\x20may\x20safely\
8453    \x20remove\x20this\x20entire\x20field\x20without\x20harming\x20runtime\n\
8454    \x20functionality\x20of\x20the\x20descriptors\x20--\x20the\x20informatio\
8455    n\x20is\x20needed\x20only\x20by\n\x20development\x20tools.\n\n\x0c\n\x05\
8456    \x04\x01\x02\n\x04\x12\x03U\x02\n\n\x0c\n\x05\x04\x01\x02\n\x06\x12\x03U\
8457    \x0b\x19\n\x0c\n\x05\x04\x01\x02\n\x01\x12\x03U\x1a*\n\x0c\n\x05\x04\x01\
8458    \x02\n\x03\x12\x03U-.\n]\n\x04\x04\x01\x02\x0b\x12\x03Y\x02\x1e\x1aP\x20\
8459    The\x20syntax\x20of\x20the\x20proto\x20file.\n\x20The\x20supported\x20va\
8460    lues\x20are\x20\"proto2\"\x20and\x20\"proto3\".\n\n\x0c\n\x05\x04\x01\
8461    \x02\x0b\x04\x12\x03Y\x02\n\n\x0c\n\x05\x04\x01\x02\x0b\x05\x12\x03Y\x0b\
8462    \x11\n\x0c\n\x05\x04\x01\x02\x0b\x01\x12\x03Y\x12\x18\n\x0c\n\x05\x04\
8463    \x01\x02\x0b\x03\x12\x03Y\x1b\x1d\n'\n\x02\x04\x02\x12\x04]\0}\x01\x1a\
8464    \x1b\x20Describes\x20a\x20message\x20type.\n\n\n\n\x03\x04\x02\x01\x12\
8465    \x03]\x08\x17\n\x0b\n\x04\x04\x02\x02\0\x12\x03^\x02\x1b\n\x0c\n\x05\x04\
8466    \x02\x02\0\x04\x12\x03^\x02\n\n\x0c\n\x05\x04\x02\x02\0\x05\x12\x03^\x0b\
8467    \x11\n\x0c\n\x05\x04\x02\x02\0\x01\x12\x03^\x12\x16\n\x0c\n\x05\x04\x02\
8468    \x02\0\x03\x12\x03^\x19\x1a\n\x0b\n\x04\x04\x02\x02\x01\x12\x03`\x02*\n\
8469    \x0c\n\x05\x04\x02\x02\x01\x04\x12\x03`\x02\n\n\x0c\n\x05\x04\x02\x02\
8470    \x01\x06\x12\x03`\x0b\x1f\n\x0c\n\x05\x04\x02\x02\x01\x01\x12\x03`\x20%\
8471    \n\x0c\n\x05\x04\x02\x02\x01\x03\x12\x03`()\n\x0b\n\x04\x04\x02\x02\x02\
8472    \x12\x03a\x02.\n\x0c\n\x05\x04\x02\x02\x02\x04\x12\x03a\x02\n\n\x0c\n\
8473    \x05\x04\x02\x02\x02\x06\x12\x03a\x0b\x1f\n\x0c\n\x05\x04\x02\x02\x02\
8474    \x01\x12\x03a\x20)\n\x0c\n\x05\x04\x02\x02\x02\x03\x12\x03a,-\n\x0b\n\
8475    \x04\x04\x02\x02\x03\x12\x03c\x02+\n\x0c\n\x05\x04\x02\x02\x03\x04\x12\
8476    \x03c\x02\n\n\x0c\n\x05\x04\x02\x02\x03\x06\x12\x03c\x0b\x1a\n\x0c\n\x05\
8477    \x04\x02\x02\x03\x01\x12\x03c\x1b&\n\x0c\n\x05\x04\x02\x02\x03\x03\x12\
8478    \x03c)*\n\x0b\n\x04\x04\x02\x02\x04\x12\x03d\x02-\n\x0c\n\x05\x04\x02\
8479    \x02\x04\x04\x12\x03d\x02\n\n\x0c\n\x05\x04\x02\x02\x04\x06\x12\x03d\x0b\
8480    \x1e\n\x0c\n\x05\x04\x02\x02\x04\x01\x12\x03d\x1f(\n\x0c\n\x05\x04\x02\
8481    \x02\x04\x03\x12\x03d+,\n\x0c\n\x04\x04\x02\x03\0\x12\x04f\x02k\x03\n\
8482    \x0c\n\x05\x04\x02\x03\0\x01\x12\x03f\n\x18\n\x1b\n\x06\x04\x02\x03\0\
8483    \x02\0\x12\x03g\x04\x1d\"\x0c\x20Inclusive.\n\n\x0e\n\x07\x04\x02\x03\0\
8484    \x02\0\x04\x12\x03g\x04\x0c\n\x0e\n\x07\x04\x02\x03\0\x02\0\x05\x12\x03g\
8485    \r\x12\n\x0e\n\x07\x04\x02\x03\0\x02\0\x01\x12\x03g\x13\x18\n\x0e\n\x07\
8486    \x04\x02\x03\0\x02\0\x03\x12\x03g\x1b\x1c\n\x1b\n\x06\x04\x02\x03\0\x02\
8487    \x01\x12\x03h\x04\x1b\"\x0c\x20Exclusive.\n\n\x0e\n\x07\x04\x02\x03\0\
8488    \x02\x01\x04\x12\x03h\x04\x0c\n\x0e\n\x07\x04\x02\x03\0\x02\x01\x05\x12\
8489    \x03h\r\x12\n\x0e\n\x07\x04\x02\x03\0\x02\x01\x01\x12\x03h\x13\x16\n\x0e\
8490    \n\x07\x04\x02\x03\0\x02\x01\x03\x12\x03h\x19\x1a\n\r\n\x06\x04\x02\x03\
8491    \0\x02\x02\x12\x03j\x04/\n\x0e\n\x07\x04\x02\x03\0\x02\x02\x04\x12\x03j\
8492    \x04\x0c\n\x0e\n\x07\x04\x02\x03\0\x02\x02\x06\x12\x03j\r\"\n\x0e\n\x07\
8493    \x04\x02\x03\0\x02\x02\x01\x12\x03j#*\n\x0e\n\x07\x04\x02\x03\0\x02\x02\
8494    \x03\x12\x03j-.\n\x0b\n\x04\x04\x02\x02\x05\x12\x03l\x02.\n\x0c\n\x05\
8495    \x04\x02\x02\x05\x04\x12\x03l\x02\n\n\x0c\n\x05\x04\x02\x02\x05\x06\x12\
8496    \x03l\x0b\x19\n\x0c\n\x05\x04\x02\x02\x05\x01\x12\x03l\x1a)\n\x0c\n\x05\
8497    \x04\x02\x02\x05\x03\x12\x03l,-\n\x0b\n\x04\x04\x02\x02\x06\x12\x03n\x02\
8498    /\n\x0c\n\x05\x04\x02\x02\x06\x04\x12\x03n\x02\n\n\x0c\n\x05\x04\x02\x02\
8499    \x06\x06\x12\x03n\x0b\x1f\n\x0c\n\x05\x04\x02\x02\x06\x01\x12\x03n\x20*\
8500    \n\x0c\n\x05\x04\x02\x02\x06\x03\x12\x03n-.\n\x0b\n\x04\x04\x02\x02\x07\
8501    \x12\x03p\x02&\n\x0c\n\x05\x04\x02\x02\x07\x04\x12\x03p\x02\n\n\x0c\n\
8502    \x05\x04\x02\x02\x07\x06\x12\x03p\x0b\x19\n\x0c\n\x05\x04\x02\x02\x07\
8503    \x01\x12\x03p\x1a!\n\x0c\n\x05\x04\x02\x02\x07\x03\x12\x03p$%\n\xaa\x01\
8504    \n\x04\x04\x02\x03\x01\x12\x04u\x02x\x03\x1a\x9b\x01\x20Range\x20of\x20r\
8505    eserved\x20tag\x20numbers.\x20Reserved\x20tag\x20numbers\x20may\x20not\
8506    \x20be\x20used\x20by\n\x20fields\x20or\x20extension\x20ranges\x20in\x20t\
8507    he\x20same\x20message.\x20Reserved\x20ranges\x20may\n\x20not\x20overlap.\
8508    \n\n\x0c\n\x05\x04\x02\x03\x01\x01\x12\x03u\n\x17\n\x1b\n\x06\x04\x02\
8509    \x03\x01\x02\0\x12\x03v\x04\x1d\"\x0c\x20Inclusive.\n\n\x0e\n\x07\x04\
8510    \x02\x03\x01\x02\0\x04\x12\x03v\x04\x0c\n\x0e\n\x07\x04\x02\x03\x01\x02\
8511    \0\x05\x12\x03v\r\x12\n\x0e\n\x07\x04\x02\x03\x01\x02\0\x01\x12\x03v\x13\
8512    \x18\n\x0e\n\x07\x04\x02\x03\x01\x02\0\x03\x12\x03v\x1b\x1c\n\x1b\n\x06\
8513    \x04\x02\x03\x01\x02\x01\x12\x03w\x04\x1b\"\x0c\x20Exclusive.\n\n\x0e\n\
8514    \x07\x04\x02\x03\x01\x02\x01\x04\x12\x03w\x04\x0c\n\x0e\n\x07\x04\x02\
8515    \x03\x01\x02\x01\x05\x12\x03w\r\x12\n\x0e\n\x07\x04\x02\x03\x01\x02\x01\
8516    \x01\x12\x03w\x13\x16\n\x0e\n\x07\x04\x02\x03\x01\x02\x01\x03\x12\x03w\
8517    \x19\x1a\n\x0b\n\x04\x04\x02\x02\x08\x12\x03y\x02,\n\x0c\n\x05\x04\x02\
8518    \x02\x08\x04\x12\x03y\x02\n\n\x0c\n\x05\x04\x02\x02\x08\x06\x12\x03y\x0b\
8519    \x18\n\x0c\n\x05\x04\x02\x02\x08\x01\x12\x03y\x19'\n\x0c\n\x05\x04\x02\
8520    \x02\x08\x03\x12\x03y*+\n\x82\x01\n\x04\x04\x02\x02\t\x12\x03|\x02%\x1au\
8521    \x20Reserved\x20field\x20names,\x20which\x20may\x20not\x20be\x20used\x20\
8522    by\x20fields\x20in\x20the\x20same\x20message.\n\x20A\x20given\x20name\
8523    \x20may\x20only\x20be\x20reserved\x20once.\n\n\x0c\n\x05\x04\x02\x02\t\
8524    \x04\x12\x03|\x02\n\n\x0c\n\x05\x04\x02\x02\t\x05\x12\x03|\x0b\x11\n\x0c\
8525    \n\x05\x04\x02\x02\t\x01\x12\x03|\x12\x1f\n\x0c\n\x05\x04\x02\x02\t\x03\
8526    \x12\x03|\"$\n\x0b\n\x02\x04\x03\x12\x05\x7f\0\x86\x01\x01\n\n\n\x03\x04\
8527    \x03\x01\x12\x03\x7f\x08\x1d\nO\n\x04\x04\x03\x02\0\x12\x04\x81\x01\x02:\
8528    \x1aA\x20The\x20parser\x20stores\x20options\x20it\x20doesn't\x20recogniz\
8529    e\x20here.\x20See\x20above.\n\n\r\n\x05\x04\x03\x02\0\x04\x12\x04\x81\
8530    \x01\x02\n\n\r\n\x05\x04\x03\x02\0\x06\x12\x04\x81\x01\x0b\x1e\n\r\n\x05\
8531    \x04\x03\x02\0\x01\x12\x04\x81\x01\x1f3\n\r\n\x05\x04\x03\x02\0\x03\x12\
8532    \x04\x81\x0169\nZ\n\x03\x04\x03\x05\x12\x04\x85\x01\x02\x19\x1aM\x20Clie\
8533    nts\x20can\x20define\x20custom\x20options\x20in\x20extensions\x20of\x20t\
8534    his\x20message.\x20See\x20above.\n\n\x0c\n\x04\x04\x03\x05\0\x12\x04\x85\
8535    \x01\r\x18\n\r\n\x05\x04\x03\x05\0\x01\x12\x04\x85\x01\r\x11\n\r\n\x05\
8536    \x04\x03\x05\0\x02\x12\x04\x85\x01\x15\x18\n3\n\x02\x04\x04\x12\x06\x89\
8537    \x01\0\xee\x01\x01\x1a%\x20Describes\x20a\x20field\x20within\x20a\x20mes\
8538    sage.\n\n\x0b\n\x03\x04\x04\x01\x12\x04\x89\x01\x08\x1c\n\x0e\n\x04\x04\
8539    \x04\x04\0\x12\x06\x8a\x01\x02\xa9\x01\x03\n\r\n\x05\x04\x04\x04\0\x01\
8540    \x12\x04\x8a\x01\x07\x0b\nS\n\x06\x04\x04\x04\0\x02\0\x12\x04\x8d\x01\
8541    \x04\x14\x1aC\x200\x20is\x20reserved\x20for\x20errors.\n\x20Order\x20is\
8542    \x20weird\x20for\x20historical\x20reasons.\n\n\x0f\n\x07\x04\x04\x04\0\
8543    \x02\0\x01\x12\x04\x8d\x01\x04\x0f\n\x0f\n\x07\x04\x04\x04\0\x02\0\x02\
8544    \x12\x04\x8d\x01\x12\x13\n\x0e\n\x06\x04\x04\x04\0\x02\x01\x12\x04\x8e\
8545    \x01\x04\x13\n\x0f\n\x07\x04\x04\x04\0\x02\x01\x01\x12\x04\x8e\x01\x04\
8546    \x0e\n\x0f\n\x07\x04\x04\x04\0\x02\x01\x02\x12\x04\x8e\x01\x11\x12\nw\n\
8547    \x06\x04\x04\x04\0\x02\x02\x12\x04\x91\x01\x04\x13\x1ag\x20Not\x20ZigZag\
8548    \x20encoded.\x20\x20Negative\x20numbers\x20take\x2010\x20bytes.\x20\x20U\
8549    se\x20TYPE_SINT64\x20if\n\x20negative\x20values\x20are\x20likely.\n\n\
8550    \x0f\n\x07\x04\x04\x04\0\x02\x02\x01\x12\x04\x91\x01\x04\x0e\n\x0f\n\x07\
8551    \x04\x04\x04\0\x02\x02\x02\x12\x04\x91\x01\x11\x12\n\x0e\n\x06\x04\x04\
8552    \x04\0\x02\x03\x12\x04\x92\x01\x04\x14\n\x0f\n\x07\x04\x04\x04\0\x02\x03\
8553    \x01\x12\x04\x92\x01\x04\x0f\n\x0f\n\x07\x04\x04\x04\0\x02\x03\x02\x12\
8554    \x04\x92\x01\x12\x13\nw\n\x06\x04\x04\x04\0\x02\x04\x12\x04\x95\x01\x04\
8555    \x13\x1ag\x20Not\x20ZigZag\x20encoded.\x20\x20Negative\x20numbers\x20tak\
8556    e\x2010\x20bytes.\x20\x20Use\x20TYPE_SINT32\x20if\n\x20negative\x20value\
8557    s\x20are\x20likely.\n\n\x0f\n\x07\x04\x04\x04\0\x02\x04\x01\x12\x04\x95\
8558    \x01\x04\x0e\n\x0f\n\x07\x04\x04\x04\0\x02\x04\x02\x12\x04\x95\x01\x11\
8559    \x12\n\x0e\n\x06\x04\x04\x04\0\x02\x05\x12\x04\x96\x01\x04\x15\n\x0f\n\
8560    \x07\x04\x04\x04\0\x02\x05\x01\x12\x04\x96\x01\x04\x10\n\x0f\n\x07\x04\
8561    \x04\x04\0\x02\x05\x02\x12\x04\x96\x01\x13\x14\n\x0e\n\x06\x04\x04\x04\0\
8562    \x02\x06\x12\x04\x97\x01\x04\x15\n\x0f\n\x07\x04\x04\x04\0\x02\x06\x01\
8563    \x12\x04\x97\x01\x04\x10\n\x0f\n\x07\x04\x04\x04\0\x02\x06\x02\x12\x04\
8564    \x97\x01\x13\x14\n\x0e\n\x06\x04\x04\x04\0\x02\x07\x12\x04\x98\x01\x04\
8565    \x12\n\x0f\n\x07\x04\x04\x04\0\x02\x07\x01\x12\x04\x98\x01\x04\r\n\x0f\n\
8566    \x07\x04\x04\x04\0\x02\x07\x02\x12\x04\x98\x01\x10\x11\n\x0e\n\x06\x04\
8567    \x04\x04\0\x02\x08\x12\x04\x99\x01\x04\x14\n\x0f\n\x07\x04\x04\x04\0\x02\
8568    \x08\x01\x12\x04\x99\x01\x04\x0f\n\x0f\n\x07\x04\x04\x04\0\x02\x08\x02\
8569    \x12\x04\x99\x01\x12\x13\n\xe2\x01\n\x06\x04\x04\x04\0\x02\t\x12\x04\x9e\
8570    \x01\x04\x14\x1a\xd1\x01\x20Tag-delimited\x20aggregate.\n\x20Group\x20ty\
8571    pe\x20is\x20deprecated\x20and\x20not\x20supported\x20in\x20proto3.\x20Ho\
8572    wever,\x20Proto3\n\x20implementations\x20should\x20still\x20be\x20able\
8573    \x20to\x20parse\x20the\x20group\x20wire\x20format\x20and\n\x20treat\x20g\
8574    roup\x20fields\x20as\x20unknown\x20fields.\n\n\x0f\n\x07\x04\x04\x04\0\
8575    \x02\t\x01\x12\x04\x9e\x01\x04\x0e\n\x0f\n\x07\x04\x04\x04\0\x02\t\x02\
8576    \x12\x04\x9e\x01\x11\x13\n-\n\x06\x04\x04\x04\0\x02\n\x12\x04\x9f\x01\
8577    \x04\x16\"\x1d\x20Length-delimited\x20aggregate.\n\n\x0f\n\x07\x04\x04\
8578    \x04\0\x02\n\x01\x12\x04\x9f\x01\x04\x10\n\x0f\n\x07\x04\x04\x04\0\x02\n\
8579    \x02\x12\x04\x9f\x01\x13\x15\n#\n\x06\x04\x04\x04\0\x02\x0b\x12\x04\xa2\
8580    \x01\x04\x14\x1a\x13\x20New\x20in\x20version\x202.\n\n\x0f\n\x07\x04\x04\
8581    \x04\0\x02\x0b\x01\x12\x04\xa2\x01\x04\x0e\n\x0f\n\x07\x04\x04\x04\0\x02\
8582    \x0b\x02\x12\x04\xa2\x01\x11\x13\n\x0e\n\x06\x04\x04\x04\0\x02\x0c\x12\
8583    \x04\xa3\x01\x04\x15\n\x0f\n\x07\x04\x04\x04\0\x02\x0c\x01\x12\x04\xa3\
8584    \x01\x04\x0f\n\x0f\n\x07\x04\x04\x04\0\x02\x0c\x02\x12\x04\xa3\x01\x12\
8585    \x14\n\x0e\n\x06\x04\x04\x04\0\x02\r\x12\x04\xa4\x01\x04\x13\n\x0f\n\x07\
8586    \x04\x04\x04\0\x02\r\x01\x12\x04\xa4\x01\x04\r\n\x0f\n\x07\x04\x04\x04\0\
8587    \x02\r\x02\x12\x04\xa4\x01\x10\x12\n\x0e\n\x06\x04\x04\x04\0\x02\x0e\x12\
8588    \x04\xa5\x01\x04\x17\n\x0f\n\x07\x04\x04\x04\0\x02\x0e\x01\x12\x04\xa5\
8589    \x01\x04\x11\n\x0f\n\x07\x04\x04\x04\0\x02\x0e\x02\x12\x04\xa5\x01\x14\
8590    \x16\n\x0e\n\x06\x04\x04\x04\0\x02\x0f\x12\x04\xa6\x01\x04\x17\n\x0f\n\
8591    \x07\x04\x04\x04\0\x02\x0f\x01\x12\x04\xa6\x01\x04\x11\n\x0f\n\x07\x04\
8592    \x04\x04\0\x02\x0f\x02\x12\x04\xa6\x01\x14\x16\n'\n\x06\x04\x04\x04\0\
8593    \x02\x10\x12\x04\xa7\x01\x04\x15\"\x17\x20Uses\x20ZigZag\x20encoding.\n\
8594    \n\x0f\n\x07\x04\x04\x04\0\x02\x10\x01\x12\x04\xa7\x01\x04\x0f\n\x0f\n\
8595    \x07\x04\x04\x04\0\x02\x10\x02\x12\x04\xa7\x01\x12\x14\n'\n\x06\x04\x04\
8596    \x04\0\x02\x11\x12\x04\xa8\x01\x04\x15\"\x17\x20Uses\x20ZigZag\x20encodi\
8597    ng.\n\n\x0f\n\x07\x04\x04\x04\0\x02\x11\x01\x12\x04\xa8\x01\x04\x0f\n\
8598    \x0f\n\x07\x04\x04\x04\0\x02\x11\x02\x12\x04\xa8\x01\x12\x14\n\x0e\n\x04\
8599    \x04\x04\x04\x01\x12\x06\xab\x01\x02\xb0\x01\x03\n\r\n\x05\x04\x04\x04\
8600    \x01\x01\x12\x04\xab\x01\x07\x0c\n*\n\x06\x04\x04\x04\x01\x02\0\x12\x04\
8601    \xad\x01\x04\x17\x1a\x1a\x200\x20is\x20reserved\x20for\x20errors\n\n\x0f\
8602    \n\x07\x04\x04\x04\x01\x02\0\x01\x12\x04\xad\x01\x04\x12\n\x0f\n\x07\x04\
8603    \x04\x04\x01\x02\0\x02\x12\x04\xad\x01\x15\x16\n\x0e\n\x06\x04\x04\x04\
8604    \x01\x02\x01\x12\x04\xae\x01\x04\x17\n\x0f\n\x07\x04\x04\x04\x01\x02\x01\
8605    \x01\x12\x04\xae\x01\x04\x12\n\x0f\n\x07\x04\x04\x04\x01\x02\x01\x02\x12\
8606    \x04\xae\x01\x15\x16\n\x0e\n\x06\x04\x04\x04\x01\x02\x02\x12\x04\xaf\x01\
8607    \x04\x17\n\x0f\n\x07\x04\x04\x04\x01\x02\x02\x01\x12\x04\xaf\x01\x04\x12\
8608    \n\x0f\n\x07\x04\x04\x04\x01\x02\x02\x02\x12\x04\xaf\x01\x15\x16\n\x0c\n\
8609    \x04\x04\x04\x02\0\x12\x04\xb2\x01\x02\x1b\n\r\n\x05\x04\x04\x02\0\x04\
8610    \x12\x04\xb2\x01\x02\n\n\r\n\x05\x04\x04\x02\0\x05\x12\x04\xb2\x01\x0b\
8611    \x11\n\r\n\x05\x04\x04\x02\0\x01\x12\x04\xb2\x01\x12\x16\n\r\n\x05\x04\
8612    \x04\x02\0\x03\x12\x04\xb2\x01\x19\x1a\n\x0c\n\x04\x04\x04\x02\x01\x12\
8613    \x04\xb3\x01\x02\x1c\n\r\n\x05\x04\x04\x02\x01\x04\x12\x04\xb3\x01\x02\n\
8614    \n\r\n\x05\x04\x04\x02\x01\x05\x12\x04\xb3\x01\x0b\x10\n\r\n\x05\x04\x04\
8615    \x02\x01\x01\x12\x04\xb3\x01\x11\x17\n\r\n\x05\x04\x04\x02\x01\x03\x12\
8616    \x04\xb3\x01\x1a\x1b\n\x0c\n\x04\x04\x04\x02\x02\x12\x04\xb4\x01\x02\x1b\
8617    \n\r\n\x05\x04\x04\x02\x02\x04\x12\x04\xb4\x01\x02\n\n\r\n\x05\x04\x04\
8618    \x02\x02\x06\x12\x04\xb4\x01\x0b\x10\n\r\n\x05\x04\x04\x02\x02\x01\x12\
8619    \x04\xb4\x01\x11\x16\n\r\n\x05\x04\x04\x02\x02\x03\x12\x04\xb4\x01\x19\
8620    \x1a\n\x9c\x01\n\x04\x04\x04\x02\x03\x12\x04\xb8\x01\x02\x19\x1a\x8d\x01\
8621    \x20If\x20type_name\x20is\x20set,\x20this\x20need\x20not\x20be\x20set.\
8622    \x20\x20If\x20both\x20this\x20and\x20type_name\n\x20are\x20set,\x20this\
8623    \x20must\x20be\x20one\x20of\x20TYPE_ENUM,\x20TYPE_MESSAGE\x20or\x20TYPE_\
8624    GROUP.\n\n\r\n\x05\x04\x04\x02\x03\x04\x12\x04\xb8\x01\x02\n\n\r\n\x05\
8625    \x04\x04\x02\x03\x06\x12\x04\xb8\x01\x0b\x0f\n\r\n\x05\x04\x04\x02\x03\
8626    \x01\x12\x04\xb8\x01\x10\x14\n\r\n\x05\x04\x04\x02\x03\x03\x12\x04\xb8\
8627    \x01\x17\x18\n\xb7\x02\n\x04\x04\x04\x02\x04\x12\x04\xbf\x01\x02\x20\x1a\
8628    \xa8\x02\x20For\x20message\x20and\x20enum\x20types,\x20this\x20is\x20the\
8629    \x20name\x20of\x20the\x20type.\x20\x20If\x20the\x20name\n\x20starts\x20w\
8630    ith\x20a\x20'.',\x20it\x20is\x20fully-qualified.\x20\x20Otherwise,\x20C+\
8631    +-like\x20scoping\n\x20rules\x20are\x20used\x20to\x20find\x20the\x20type\
8632    \x20(i.e.\x20first\x20the\x20nested\x20types\x20within\x20this\n\x20mess\
8633    age\x20are\x20searched,\x20then\x20within\x20the\x20parent,\x20on\x20up\
8634    \x20to\x20the\x20root\n\x20namespace).\n\n\r\n\x05\x04\x04\x02\x04\x04\
8635    \x12\x04\xbf\x01\x02\n\n\r\n\x05\x04\x04\x02\x04\x05\x12\x04\xbf\x01\x0b\
8636    \x11\n\r\n\x05\x04\x04\x02\x04\x01\x12\x04\xbf\x01\x12\x1b\n\r\n\x05\x04\
8637    \x04\x02\x04\x03\x12\x04\xbf\x01\x1e\x1f\n~\n\x04\x04\x04\x02\x05\x12\
8638    \x04\xc3\x01\x02\x1f\x1ap\x20For\x20extensions,\x20this\x20is\x20the\x20\
8639    name\x20of\x20the\x20type\x20being\x20extended.\x20\x20It\x20is\n\x20res\
8640    olved\x20in\x20the\x20same\x20manner\x20as\x20type_name.\n\n\r\n\x05\x04\
8641    \x04\x02\x05\x04\x12\x04\xc3\x01\x02\n\n\r\n\x05\x04\x04\x02\x05\x05\x12\
8642    \x04\xc3\x01\x0b\x11\n\r\n\x05\x04\x04\x02\x05\x01\x12\x04\xc3\x01\x12\
8643    \x1a\n\r\n\x05\x04\x04\x02\x05\x03\x12\x04\xc3\x01\x1d\x1e\n\xb1\x02\n\
8644    \x04\x04\x04\x02\x06\x12\x04\xca\x01\x02$\x1a\xa2\x02\x20For\x20numeric\
8645    \x20types,\x20contains\x20the\x20original\x20text\x20representation\x20o\
8646    f\x20the\x20value.\n\x20For\x20booleans,\x20\"true\"\x20or\x20\"false\".\
8647    \n\x20For\x20strings,\x20contains\x20the\x20default\x20text\x20contents\
8648    \x20(not\x20escaped\x20in\x20any\x20way).\n\x20For\x20bytes,\x20contains\
8649    \x20the\x20C\x20escaped\x20value.\x20\x20All\x20bytes\x20>=\x20128\x20ar\
8650    e\x20escaped.\n\x20TODO(kenton):\x20\x20Base-64\x20encode?\n\n\r\n\x05\
8651    \x04\x04\x02\x06\x04\x12\x04\xca\x01\x02\n\n\r\n\x05\x04\x04\x02\x06\x05\
8652    \x12\x04\xca\x01\x0b\x11\n\r\n\x05\x04\x04\x02\x06\x01\x12\x04\xca\x01\
8653    \x12\x1f\n\r\n\x05\x04\x04\x02\x06\x03\x12\x04\xca\x01\"#\n\x84\x01\n\
8654    \x04\x04\x04\x02\x07\x12\x04\xce\x01\x02!\x1av\x20If\x20set,\x20gives\
8655    \x20the\x20index\x20of\x20a\x20oneof\x20in\x20the\x20containing\x20type'\
8656    s\x20oneof_decl\n\x20list.\x20\x20This\x20field\x20is\x20a\x20member\x20\
8657    of\x20that\x20oneof.\n\n\r\n\x05\x04\x04\x02\x07\x04\x12\x04\xce\x01\x02\
8658    \n\n\r\n\x05\x04\x04\x02\x07\x05\x12\x04\xce\x01\x0b\x10\n\r\n\x05\x04\
8659    \x04\x02\x07\x01\x12\x04\xce\x01\x11\x1c\n\r\n\x05\x04\x04\x02\x07\x03\
8660    \x12\x04\xce\x01\x1f\x20\n\xfa\x01\n\x04\x04\x04\x02\x08\x12\x04\xd4\x01\
8661    \x02!\x1a\xeb\x01\x20JSON\x20name\x20of\x20this\x20field.\x20The\x20valu\
8662    e\x20is\x20set\x20by\x20protocol\x20compiler.\x20If\x20the\n\x20user\x20\
8663    has\x20set\x20a\x20\"json_name\"\x20option\x20on\x20this\x20field,\x20th\
8664    at\x20option's\x20value\n\x20will\x20be\x20used.\x20Otherwise,\x20it's\
8665    \x20deduced\x20from\x20the\x20field's\x20name\x20by\x20converting\n\x20i\
8666    t\x20to\x20camelCase.\n\n\r\n\x05\x04\x04\x02\x08\x04\x12\x04\xd4\x01\
8667    \x02\n\n\r\n\x05\x04\x04\x02\x08\x05\x12\x04\xd4\x01\x0b\x11\n\r\n\x05\
8668    \x04\x04\x02\x08\x01\x12\x04\xd4\x01\x12\x1b\n\r\n\x05\x04\x04\x02\x08\
8669    \x03\x12\x04\xd4\x01\x1e\x20\n\x0c\n\x04\x04\x04\x02\t\x12\x04\xd6\x01\
8670    \x02$\n\r\n\x05\x04\x04\x02\t\x04\x12\x04\xd6\x01\x02\n\n\r\n\x05\x04\
8671    \x04\x02\t\x06\x12\x04\xd6\x01\x0b\x17\n\r\n\x05\x04\x04\x02\t\x01\x12\
8672    \x04\xd6\x01\x18\x1f\n\r\n\x05\x04\x04\x02\t\x03\x12\x04\xd6\x01\"#\n\
8673    \xb3\t\n\x04\x04\x04\x02\n\x12\x04\xed\x01\x02%\x1a\xa4\t\x20If\x20true,\
8674    \x20this\x20is\x20a\x20proto3\x20\"optional\".\x20When\x20a\x20proto3\
8675    \x20field\x20is\x20optional,\x20it\n\x20tracks\x20presence\x20regardless\
8676    \x20of\x20field\x20type.\n\n\x20When\x20proto3_optional\x20is\x20true,\
8677    \x20this\x20field\x20must\x20be\x20belong\x20to\x20a\x20oneof\x20to\n\
8678    \x20signal\x20to\x20old\x20proto3\x20clients\x20that\x20presence\x20is\
8679    \x20tracked\x20for\x20this\x20field.\x20This\n\x20oneof\x20is\x20known\
8680    \x20as\x20a\x20\"synthetic\"\x20oneof,\x20and\x20this\x20field\x20must\
8681    \x20be\x20its\x20sole\n\x20member\x20(each\x20proto3\x20optional\x20fiel\
8682    d\x20gets\x20its\x20own\x20synthetic\x20oneof).\x20Synthetic\n\x20oneofs\
8683    \x20exist\x20in\x20the\x20descriptor\x20only,\x20and\x20do\x20not\x20gen\
8684    erate\x20any\x20API.\x20Synthetic\n\x20oneofs\x20must\x20be\x20ordered\
8685    \x20after\x20all\x20\"real\"\x20oneofs.\n\n\x20For\x20message\x20fields,\
8686    \x20proto3_optional\x20doesn't\x20create\x20any\x20semantic\x20change,\n\
8687    \x20since\x20non-repeated\x20message\x20fields\x20always\x20track\x20pre\
8688    sence.\x20However\x20it\x20still\n\x20indicates\x20the\x20semantic\x20de\
8689    tail\x20of\x20whether\x20the\x20user\x20wrote\x20\"optional\"\x20or\x20n\
8690    ot.\n\x20This\x20can\x20be\x20useful\x20for\x20round-tripping\x20the\x20\
8691    .proto\x20file.\x20For\x20consistency\x20we\n\x20give\x20message\x20fiel\
8692    ds\x20a\x20synthetic\x20oneof\x20also,\x20even\x20though\x20it\x20is\x20\
8693    not\x20required\n\x20to\x20track\x20presence.\x20This\x20is\x20especiall\
8694    y\x20important\x20because\x20the\x20parser\x20can't\n\x20tell\x20if\x20a\
8695    \x20field\x20is\x20a\x20message\x20or\x20an\x20enum,\x20so\x20it\x20must\
8696    \x20always\x20create\x20a\n\x20synthetic\x20oneof.\n\n\x20Proto2\x20opti\
8697    onal\x20fields\x20do\x20not\x20set\x20this\x20flag,\x20because\x20they\
8698    \x20already\x20indicate\n\x20optional\x20with\x20`LABEL_OPTIONAL`.\n\n\r\
8699    \n\x05\x04\x04\x02\n\x04\x12\x04\xed\x01\x02\n\n\r\n\x05\x04\x04\x02\n\
8700    \x05\x12\x04\xed\x01\x0b\x0f\n\r\n\x05\x04\x04\x02\n\x01\x12\x04\xed\x01\
8701    \x10\x1f\n\r\n\x05\x04\x04\x02\n\x03\x12\x04\xed\x01\"$\n\"\n\x02\x04\
8702    \x05\x12\x06\xf1\x01\0\xf4\x01\x01\x1a\x14\x20Describes\x20a\x20oneof.\n\
8703    \n\x0b\n\x03\x04\x05\x01\x12\x04\xf1\x01\x08\x1c\n\x0c\n\x04\x04\x05\x02\
8704    \0\x12\x04\xf2\x01\x02\x1b\n\r\n\x05\x04\x05\x02\0\x04\x12\x04\xf2\x01\
8705    \x02\n\n\r\n\x05\x04\x05\x02\0\x05\x12\x04\xf2\x01\x0b\x11\n\r\n\x05\x04\
8706    \x05\x02\0\x01\x12\x04\xf2\x01\x12\x16\n\r\n\x05\x04\x05\x02\0\x03\x12\
8707    \x04\xf2\x01\x19\x1a\n\x0c\n\x04\x04\x05\x02\x01\x12\x04\xf3\x01\x02$\n\
8708    \r\n\x05\x04\x05\x02\x01\x04\x12\x04\xf3\x01\x02\n\n\r\n\x05\x04\x05\x02\
8709    \x01\x06\x12\x04\xf3\x01\x0b\x17\n\r\n\x05\x04\x05\x02\x01\x01\x12\x04\
8710    \xf3\x01\x18\x1f\n\r\n\x05\x04\x05\x02\x01\x03\x12\x04\xf3\x01\"#\n'\n\
8711    \x02\x04\x06\x12\x06\xf7\x01\0\x91\x02\x01\x1a\x19\x20Describes\x20an\
8712    \x20enum\x20type.\n\n\x0b\n\x03\x04\x06\x01\x12\x04\xf7\x01\x08\x1b\n\
8713    \x0c\n\x04\x04\x06\x02\0\x12\x04\xf8\x01\x02\x1b\n\r\n\x05\x04\x06\x02\0\
8714    \x04\x12\x04\xf8\x01\x02\n\n\r\n\x05\x04\x06\x02\0\x05\x12\x04\xf8\x01\
8715    \x0b\x11\n\r\n\x05\x04\x06\x02\0\x01\x12\x04\xf8\x01\x12\x16\n\r\n\x05\
8716    \x04\x06\x02\0\x03\x12\x04\xf8\x01\x19\x1a\n\x0c\n\x04\x04\x06\x02\x01\
8717    \x12\x04\xfa\x01\x02.\n\r\n\x05\x04\x06\x02\x01\x04\x12\x04\xfa\x01\x02\
8718    \n\n\r\n\x05\x04\x06\x02\x01\x06\x12\x04\xfa\x01\x0b#\n\r\n\x05\x04\x06\
8719    \x02\x01\x01\x12\x04\xfa\x01$)\n\r\n\x05\x04\x06\x02\x01\x03\x12\x04\xfa\
8720    \x01,-\n\x0c\n\x04\x04\x06\x02\x02\x12\x04\xfc\x01\x02#\n\r\n\x05\x04\
8721    \x06\x02\x02\x04\x12\x04\xfc\x01\x02\n\n\r\n\x05\x04\x06\x02\x02\x06\x12\
8722    \x04\xfc\x01\x0b\x16\n\r\n\x05\x04\x06\x02\x02\x01\x12\x04\xfc\x01\x17\
8723    \x1e\n\r\n\x05\x04\x06\x02\x02\x03\x12\x04\xfc\x01!\"\n\xaf\x02\n\x04\
8724    \x04\x06\x03\0\x12\x06\x84\x02\x02\x87\x02\x03\x1a\x9e\x02\x20Range\x20o\
8725    f\x20reserved\x20numeric\x20values.\x20Reserved\x20values\x20may\x20not\
8726    \x20be\x20used\x20by\n\x20entries\x20in\x20the\x20same\x20enum.\x20Reser\
8727    ved\x20ranges\x20may\x20not\x20overlap.\n\n\x20Note\x20that\x20this\x20i\
8728    s\x20distinct\x20from\x20DescriptorProto.ReservedRange\x20in\x20that\x20\
8729    it\n\x20is\x20inclusive\x20such\x20that\x20it\x20can\x20appropriately\
8730    \x20represent\x20the\x20entire\x20int32\n\x20domain.\n\n\r\n\x05\x04\x06\
8731    \x03\0\x01\x12\x04\x84\x02\n\x1b\n\x1c\n\x06\x04\x06\x03\0\x02\0\x12\x04\
8732    \x85\x02\x04\x1d\"\x0c\x20Inclusive.\n\n\x0f\n\x07\x04\x06\x03\0\x02\0\
8733    \x04\x12\x04\x85\x02\x04\x0c\n\x0f\n\x07\x04\x06\x03\0\x02\0\x05\x12\x04\
8734    \x85\x02\r\x12\n\x0f\n\x07\x04\x06\x03\0\x02\0\x01\x12\x04\x85\x02\x13\
8735    \x18\n\x0f\n\x07\x04\x06\x03\0\x02\0\x03\x12\x04\x85\x02\x1b\x1c\n\x1c\n\
8736    \x06\x04\x06\x03\0\x02\x01\x12\x04\x86\x02\x04\x1b\"\x0c\x20Inclusive.\n\
8737    \n\x0f\n\x07\x04\x06\x03\0\x02\x01\x04\x12\x04\x86\x02\x04\x0c\n\x0f\n\
8738    \x07\x04\x06\x03\0\x02\x01\x05\x12\x04\x86\x02\r\x12\n\x0f\n\x07\x04\x06\
8739    \x03\0\x02\x01\x01\x12\x04\x86\x02\x13\x16\n\x0f\n\x07\x04\x06\x03\0\x02\
8740    \x01\x03\x12\x04\x86\x02\x19\x1a\n\xaa\x01\n\x04\x04\x06\x02\x03\x12\x04\
8741    \x8c\x02\x020\x1a\x9b\x01\x20Range\x20of\x20reserved\x20numeric\x20value\
8742    s.\x20Reserved\x20numeric\x20values\x20may\x20not\x20be\x20used\n\x20by\
8743    \x20enum\x20values\x20in\x20the\x20same\x20enum\x20declaration.\x20Reser\
8744    ved\x20ranges\x20may\x20not\n\x20overlap.\n\n\r\n\x05\x04\x06\x02\x03\
8745    \x04\x12\x04\x8c\x02\x02\n\n\r\n\x05\x04\x06\x02\x03\x06\x12\x04\x8c\x02\
8746    \x0b\x1c\n\r\n\x05\x04\x06\x02\x03\x01\x12\x04\x8c\x02\x1d+\n\r\n\x05\
8747    \x04\x06\x02\x03\x03\x12\x04\x8c\x02./\nl\n\x04\x04\x06\x02\x04\x12\x04\
8748    \x90\x02\x02$\x1a^\x20Reserved\x20enum\x20value\x20names,\x20which\x20ma\
8749    y\x20not\x20be\x20reused.\x20A\x20given\x20name\x20may\x20only\n\x20be\
8750    \x20reserved\x20once.\n\n\r\n\x05\x04\x06\x02\x04\x04\x12\x04\x90\x02\
8751    \x02\n\n\r\n\x05\x04\x06\x02\x04\x05\x12\x04\x90\x02\x0b\x11\n\r\n\x05\
8752    \x04\x06\x02\x04\x01\x12\x04\x90\x02\x12\x1f\n\r\n\x05\x04\x06\x02\x04\
8753    \x03\x12\x04\x90\x02\"#\n1\n\x02\x04\x07\x12\x06\x94\x02\0\x99\x02\x01\
8754    \x1a#\x20Describes\x20a\x20value\x20within\x20an\x20enum.\n\n\x0b\n\x03\
8755    \x04\x07\x01\x12\x04\x94\x02\x08\x20\n\x0c\n\x04\x04\x07\x02\0\x12\x04\
8756    \x95\x02\x02\x1b\n\r\n\x05\x04\x07\x02\0\x04\x12\x04\x95\x02\x02\n\n\r\n\
8757    \x05\x04\x07\x02\0\x05\x12\x04\x95\x02\x0b\x11\n\r\n\x05\x04\x07\x02\0\
8758    \x01\x12\x04\x95\x02\x12\x16\n\r\n\x05\x04\x07\x02\0\x03\x12\x04\x95\x02\
8759    \x19\x1a\n\x0c\n\x04\x04\x07\x02\x01\x12\x04\x96\x02\x02\x1c\n\r\n\x05\
8760    \x04\x07\x02\x01\x04\x12\x04\x96\x02\x02\n\n\r\n\x05\x04\x07\x02\x01\x05\
8761    \x12\x04\x96\x02\x0b\x10\n\r\n\x05\x04\x07\x02\x01\x01\x12\x04\x96\x02\
8762    \x11\x17\n\r\n\x05\x04\x07\x02\x01\x03\x12\x04\x96\x02\x1a\x1b\n\x0c\n\
8763    \x04\x04\x07\x02\x02\x12\x04\x98\x02\x02(\n\r\n\x05\x04\x07\x02\x02\x04\
8764    \x12\x04\x98\x02\x02\n\n\r\n\x05\x04\x07\x02\x02\x06\x12\x04\x98\x02\x0b\
8765    \x1b\n\r\n\x05\x04\x07\x02\x02\x01\x12\x04\x98\x02\x1c#\n\r\n\x05\x04\
8766    \x07\x02\x02\x03\x12\x04\x98\x02&'\n$\n\x02\x04\x08\x12\x06\x9c\x02\0\
8767    \xa1\x02\x01\x1a\x16\x20Describes\x20a\x20service.\n\n\x0b\n\x03\x04\x08\
8768    \x01\x12\x04\x9c\x02\x08\x1e\n\x0c\n\x04\x04\x08\x02\0\x12\x04\x9d\x02\
8769    \x02\x1b\n\r\n\x05\x04\x08\x02\0\x04\x12\x04\x9d\x02\x02\n\n\r\n\x05\x04\
8770    \x08\x02\0\x05\x12\x04\x9d\x02\x0b\x11\n\r\n\x05\x04\x08\x02\0\x01\x12\
8771    \x04\x9d\x02\x12\x16\n\r\n\x05\x04\x08\x02\0\x03\x12\x04\x9d\x02\x19\x1a\
8772    \n\x0c\n\x04\x04\x08\x02\x01\x12\x04\x9e\x02\x02,\n\r\n\x05\x04\x08\x02\
8773    \x01\x04\x12\x04\x9e\x02\x02\n\n\r\n\x05\x04\x08\x02\x01\x06\x12\x04\x9e\
8774    \x02\x0b\x20\n\r\n\x05\x04\x08\x02\x01\x01\x12\x04\x9e\x02!'\n\r\n\x05\
8775    \x04\x08\x02\x01\x03\x12\x04\x9e\x02*+\n\x0c\n\x04\x04\x08\x02\x02\x12\
8776    \x04\xa0\x02\x02&\n\r\n\x05\x04\x08\x02\x02\x04\x12\x04\xa0\x02\x02\n\n\
8777    \r\n\x05\x04\x08\x02\x02\x06\x12\x04\xa0\x02\x0b\x19\n\r\n\x05\x04\x08\
8778    \x02\x02\x01\x12\x04\xa0\x02\x1a!\n\r\n\x05\x04\x08\x02\x02\x03\x12\x04\
8779    \xa0\x02$%\n0\n\x02\x04\t\x12\x06\xa4\x02\0\xb2\x02\x01\x1a\"\x20Describ\
8780    es\x20a\x20method\x20of\x20a\x20service.\n\n\x0b\n\x03\x04\t\x01\x12\x04\
8781    \xa4\x02\x08\x1d\n\x0c\n\x04\x04\t\x02\0\x12\x04\xa5\x02\x02\x1b\n\r\n\
8782    \x05\x04\t\x02\0\x04\x12\x04\xa5\x02\x02\n\n\r\n\x05\x04\t\x02\0\x05\x12\
8783    \x04\xa5\x02\x0b\x11\n\r\n\x05\x04\t\x02\0\x01\x12\x04\xa5\x02\x12\x16\n\
8784    \r\n\x05\x04\t\x02\0\x03\x12\x04\xa5\x02\x19\x1a\n\x97\x01\n\x04\x04\t\
8785    \x02\x01\x12\x04\xa9\x02\x02!\x1a\x88\x01\x20Input\x20and\x20output\x20t\
8786    ype\x20names.\x20\x20These\x20are\x20resolved\x20in\x20the\x20same\x20wa\
8787    y\x20as\n\x20FieldDescriptorProto.type_name,\x20but\x20must\x20refer\x20\
8788    to\x20a\x20message\x20type.\n\n\r\n\x05\x04\t\x02\x01\x04\x12\x04\xa9\
8789    \x02\x02\n\n\r\n\x05\x04\t\x02\x01\x05\x12\x04\xa9\x02\x0b\x11\n\r\n\x05\
8790    \x04\t\x02\x01\x01\x12\x04\xa9\x02\x12\x1c\n\r\n\x05\x04\t\x02\x01\x03\
8791    \x12\x04\xa9\x02\x1f\x20\n\x0c\n\x04\x04\t\x02\x02\x12\x04\xaa\x02\x02\"\
8792    \n\r\n\x05\x04\t\x02\x02\x04\x12\x04\xaa\x02\x02\n\n\r\n\x05\x04\t\x02\
8793    \x02\x05\x12\x04\xaa\x02\x0b\x11\n\r\n\x05\x04\t\x02\x02\x01\x12\x04\xaa\
8794    \x02\x12\x1d\n\r\n\x05\x04\t\x02\x02\x03\x12\x04\xaa\x02\x20!\n\x0c\n\
8795    \x04\x04\t\x02\x03\x12\x04\xac\x02\x02%\n\r\n\x05\x04\t\x02\x03\x04\x12\
8796    \x04\xac\x02\x02\n\n\r\n\x05\x04\t\x02\x03\x06\x12\x04\xac\x02\x0b\x18\n\
8797    \r\n\x05\x04\t\x02\x03\x01\x12\x04\xac\x02\x19\x20\n\r\n\x05\x04\t\x02\
8798    \x03\x03\x12\x04\xac\x02#$\nE\n\x04\x04\t\x02\x04\x12\x04\xaf\x02\x027\
8799    \x1a7\x20Identifies\x20if\x20client\x20streams\x20multiple\x20client\x20\
8800    messages\n\n\r\n\x05\x04\t\x02\x04\x04\x12\x04\xaf\x02\x02\n\n\r\n\x05\
8801    \x04\t\x02\x04\x05\x12\x04\xaf\x02\x0b\x0f\n\r\n\x05\x04\t\x02\x04\x01\
8802    \x12\x04\xaf\x02\x10\x20\n\r\n\x05\x04\t\x02\x04\x03\x12\x04\xaf\x02#$\n\
8803    \r\n\x05\x04\t\x02\x04\x08\x12\x04\xaf\x02%6\n\r\n\x05\x04\t\x02\x04\x07\
8804    \x12\x04\xaf\x0205\nE\n\x04\x04\t\x02\x05\x12\x04\xb1\x02\x027\x1a7\x20I\
8805    dentifies\x20if\x20server\x20streams\x20multiple\x20server\x20messages\n\
8806    \n\r\n\x05\x04\t\x02\x05\x04\x12\x04\xb1\x02\x02\n\n\r\n\x05\x04\t\x02\
8807    \x05\x05\x12\x04\xb1\x02\x0b\x0f\n\r\n\x05\x04\t\x02\x05\x01\x12\x04\xb1\
8808    \x02\x10\x20\n\r\n\x05\x04\t\x02\x05\x03\x12\x04\xb1\x02#$\n\r\n\x05\x04\
8809    \t\x02\x05\x08\x12\x04\xb1\x02%6\n\r\n\x05\x04\t\x02\x05\x07\x12\x04\xb1\
8810    \x0205\n\xaf\x0e\n\x02\x04\n\x12\x06\xd5\x02\0\xd0\x03\x012N\x20========\
8811    ===========================================================\n\x20Options\
8812    \n2\xd0\r\x20Each\x20of\x20the\x20definitions\x20above\x20may\x20have\
8813    \x20\"options\"\x20attached.\x20\x20These\x20are\n\x20just\x20annotation\
8814    s\x20which\x20may\x20cause\x20code\x20to\x20be\x20generated\x20slightly\
8815    \x20differently\n\x20or\x20may\x20contain\x20hints\x20for\x20code\x20tha\
8816    t\x20manipulates\x20protocol\x20messages.\n\n\x20Clients\x20may\x20defin\
8817    e\x20custom\x20options\x20as\x20extensions\x20of\x20the\x20*Options\x20m\
8818    essages.\n\x20These\x20extensions\x20may\x20not\x20yet\x20be\x20known\
8819    \x20at\x20parsing\x20time,\x20so\x20the\x20parser\x20cannot\n\x20store\
8820    \x20the\x20values\x20in\x20them.\x20\x20Instead\x20it\x20stores\x20them\
8821    \x20in\x20a\x20field\x20in\x20the\x20*Options\n\x20message\x20called\x20\
8822    uninterpreted_option.\x20This\x20field\x20must\x20have\x20the\x20same\
8823    \x20name\n\x20across\x20all\x20*Options\x20messages.\x20We\x20then\x20us\
8824    e\x20this\x20field\x20to\x20populate\x20the\n\x20extensions\x20when\x20w\
8825    e\x20build\x20a\x20descriptor,\x20at\x20which\x20point\x20all\x20protos\
8826    \x20have\x20been\n\x20parsed\x20and\x20so\x20all\x20extensions\x20are\
8827    \x20known.\n\n\x20Extension\x20numbers\x20for\x20custom\x20options\x20ma\
8828    y\x20be\x20chosen\x20as\x20follows:\n\x20*\x20For\x20options\x20which\
8829    \x20will\x20only\x20be\x20used\x20within\x20a\x20single\x20application\
8830    \x20or\n\x20\x20\x20organization,\x20or\x20for\x20experimental\x20option\
8831    s,\x20use\x20field\x20numbers\x2050000\n\x20\x20\x20through\x2099999.\
8832    \x20\x20It\x20is\x20up\x20to\x20you\x20to\x20ensure\x20that\x20you\x20do\
8833    \x20not\x20use\x20the\n\x20\x20\x20same\x20number\x20for\x20multiple\x20\
8834    options.\n\x20*\x20For\x20options\x20which\x20will\x20be\x20published\
8835    \x20and\x20used\x20publicly\x20by\x20multiple\n\x20\x20\x20independent\
8836    \x20entities,\x20e-mail\x20protobuf-global-extension-registry@google.com\
8837    \n\x20\x20\x20to\x20reserve\x20extension\x20numbers.\x20Simply\x20provid\
8838    e\x20your\x20project\x20name\x20(e.g.\n\x20\x20\x20Objective-C\x20plugin\
8839    )\x20and\x20your\x20project\x20website\x20(if\x20available)\x20--\x20the\
8840    re's\x20no\n\x20\x20\x20need\x20to\x20explain\x20how\x20you\x20intend\
8841    \x20to\x20use\x20them.\x20Usually\x20you\x20only\x20need\x20one\n\x20\
8842    \x20\x20extension\x20number.\x20You\x20can\x20declare\x20multiple\x20opt\
8843    ions\x20with\x20only\x20one\x20extension\n\x20\x20\x20number\x20by\x20pu\
8844    tting\x20them\x20in\x20a\x20sub-message.\x20See\x20the\x20Custom\x20Opti\
8845    ons\x20section\x20of\n\x20\x20\x20the\x20docs\x20for\x20examples:\n\x20\
8846    \x20\x20https://developers.google.com/protocol-buffers/docs/proto#option\
8847    s\n\x20\x20\x20If\x20this\x20turns\x20out\x20to\x20be\x20popular,\x20a\
8848    \x20web\x20service\x20will\x20be\x20set\x20up\n\x20\x20\x20to\x20automat\
8849    ically\x20assign\x20option\x20numbers.\n\n\x0b\n\x03\x04\n\x01\x12\x04\
8850    \xd5\x02\x08\x13\n\xf4\x01\n\x04\x04\n\x02\0\x12\x04\xdb\x02\x02#\x1a\
8851    \xe5\x01\x20Sets\x20the\x20Java\x20package\x20where\x20classes\x20genera\
8852    ted\x20from\x20this\x20.proto\x20will\x20be\n\x20placed.\x20\x20By\x20de\
8853    fault,\x20the\x20proto\x20package\x20is\x20used,\x20but\x20this\x20is\
8854    \x20often\n\x20inappropriate\x20because\x20proto\x20packages\x20do\x20no\
8855    t\x20normally\x20start\x20with\x20backwards\n\x20domain\x20names.\n\n\r\
8856    \n\x05\x04\n\x02\0\x04\x12\x04\xdb\x02\x02\n\n\r\n\x05\x04\n\x02\0\x05\
8857    \x12\x04\xdb\x02\x0b\x11\n\r\n\x05\x04\n\x02\0\x01\x12\x04\xdb\x02\x12\
8858    \x1e\n\r\n\x05\x04\n\x02\0\x03\x12\x04\xdb\x02!\"\n\xf1\x02\n\x04\x04\n\
8859    \x02\x01\x12\x04\xe3\x02\x02+\x1a\xe2\x02\x20Controls\x20the\x20name\x20\
8860    of\x20the\x20wrapper\x20Java\x20class\x20generated\x20for\x20the\x20.pro\
8861    to\x20file.\n\x20That\x20class\x20will\x20always\x20contain\x20the\x20.p\
8862    roto\x20file's\x20getDescriptor()\x20method\x20as\n\x20well\x20as\x20any\
8863    \x20top-level\x20extensions\x20defined\x20in\x20the\x20.proto\x20file.\n\
8864    \x20If\x20java_multiple_files\x20is\x20disabled,\x20then\x20all\x20the\
8865    \x20other\x20classes\x20from\x20the\n\x20.proto\x20file\x20will\x20be\
8866    \x20nested\x20inside\x20the\x20single\x20wrapper\x20outer\x20class.\n\n\
8867    \r\n\x05\x04\n\x02\x01\x04\x12\x04\xe3\x02\x02\n\n\r\n\x05\x04\n\x02\x01\
8868    \x05\x12\x04\xe3\x02\x0b\x11\n\r\n\x05\x04\n\x02\x01\x01\x12\x04\xe3\x02\
8869    \x12&\n\r\n\x05\x04\n\x02\x01\x03\x12\x04\xe3\x02)*\n\xa6\x03\n\x04\x04\
8870    \n\x02\x02\x12\x04\xeb\x02\x02;\x1a\x97\x03\x20If\x20enabled,\x20then\
8871    \x20the\x20Java\x20code\x20generator\x20will\x20generate\x20a\x20separat\
8872    e\x20.java\n\x20file\x20for\x20each\x20top-level\x20message,\x20enum,\
8873    \x20and\x20service\x20defined\x20in\x20the\x20.proto\n\x20file.\x20\x20T\
8874    hus,\x20these\x20types\x20will\x20*not*\x20be\x20nested\x20inside\x20the\
8875    \x20wrapper\x20class\n\x20named\x20by\x20java_outer_classname.\x20\x20Ho\
8876    wever,\x20the\x20wrapper\x20class\x20will\x20still\x20be\n\x20generated\
8877    \x20to\x20contain\x20the\x20file's\x20getDescriptor()\x20method\x20as\
8878    \x20well\x20as\x20any\n\x20top-level\x20extensions\x20defined\x20in\x20t\
8879    he\x20file.\n\n\r\n\x05\x04\n\x02\x02\x04\x12\x04\xeb\x02\x02\n\n\r\n\
8880    \x05\x04\n\x02\x02\x05\x12\x04\xeb\x02\x0b\x0f\n\r\n\x05\x04\n\x02\x02\
8881    \x01\x12\x04\xeb\x02\x10#\n\r\n\x05\x04\n\x02\x02\x03\x12\x04\xeb\x02&(\
8882    \n\r\n\x05\x04\n\x02\x02\x08\x12\x04\xeb\x02):\n\r\n\x05\x04\n\x02\x02\
8883    \x07\x12\x04\xeb\x0249\n)\n\x04\x04\n\x02\x03\x12\x04\xee\x02\x02E\x1a\
8884    \x1b\x20This\x20option\x20does\x20nothing.\n\n\r\n\x05\x04\n\x02\x03\x04\
8885    \x12\x04\xee\x02\x02\n\n\r\n\x05\x04\n\x02\x03\x05\x12\x04\xee\x02\x0b\
8886    \x0f\n\r\n\x05\x04\n\x02\x03\x01\x12\x04\xee\x02\x10-\n\r\n\x05\x04\n\
8887    \x02\x03\x03\x12\x04\xee\x0202\n\r\n\x05\x04\n\x02\x03\x08\x12\x04\xee\
8888    \x023D\n\x0e\n\x06\x04\n\x02\x03\x08\x03\x12\x04\xee\x024C\n\xe6\x02\n\
8889    \x04\x04\n\x02\x04\x12\x04\xf6\x02\x02>\x1a\xd7\x02\x20If\x20set\x20true\
8890    ,\x20then\x20the\x20Java2\x20code\x20generator\x20will\x20generate\x20co\
8891    de\x20that\n\x20throws\x20an\x20exception\x20whenever\x20an\x20attempt\
8892    \x20is\x20made\x20to\x20assign\x20a\x20non-UTF-8\n\x20byte\x20sequence\
8893    \x20to\x20a\x20string\x20field.\n\x20Message\x20reflection\x20will\x20do\
8894    \x20the\x20same.\n\x20However,\x20an\x20extension\x20field\x20still\x20a\
8895    ccepts\x20non-UTF-8\x20byte\x20sequences.\n\x20This\x20option\x20has\x20\
8896    no\x20effect\x20on\x20when\x20used\x20with\x20the\x20lite\x20runtime.\n\
8897    \n\r\n\x05\x04\n\x02\x04\x04\x12\x04\xf6\x02\x02\n\n\r\n\x05\x04\n\x02\
8898    \x04\x05\x12\x04\xf6\x02\x0b\x0f\n\r\n\x05\x04\n\x02\x04\x01\x12\x04\xf6\
8899    \x02\x10&\n\r\n\x05\x04\n\x02\x04\x03\x12\x04\xf6\x02)+\n\r\n\x05\x04\n\
8900    \x02\x04\x08\x12\x04\xf6\x02,=\n\r\n\x05\x04\n\x02\x04\x07\x12\x04\xf6\
8901    \x027<\nL\n\x04\x04\n\x04\0\x12\x06\xfa\x02\x02\xff\x02\x03\x1a<\x20Gene\
8902    rated\x20classes\x20can\x20be\x20optimized\x20for\x20speed\x20or\x20code\
8903    \x20size.\n\n\r\n\x05\x04\n\x04\0\x01\x12\x04\xfa\x02\x07\x13\nD\n\x06\
8904    \x04\n\x04\0\x02\0\x12\x04\xfb\x02\x04\x0e\"4\x20Generate\x20complete\
8905    \x20code\x20for\x20parsing,\x20serialization,\n\n\x0f\n\x07\x04\n\x04\0\
8906    \x02\0\x01\x12\x04\xfb\x02\x04\t\n\x0f\n\x07\x04\n\x04\0\x02\0\x02\x12\
8907    \x04\xfb\x02\x0c\r\nG\n\x06\x04\n\x04\0\x02\x01\x12\x04\xfd\x02\x04\x12\
8908    \x1a\x06\x20etc.\n\"/\x20Use\x20ReflectionOps\x20to\x20implement\x20thes\
8909    e\x20methods.\n\n\x0f\n\x07\x04\n\x04\0\x02\x01\x01\x12\x04\xfd\x02\x04\
8910    \r\n\x0f\n\x07\x04\n\x04\0\x02\x01\x02\x12\x04\xfd\x02\x10\x11\nG\n\x06\
8911    \x04\n\x04\0\x02\x02\x12\x04\xfe\x02\x04\x15\"7\x20Generate\x20code\x20u\
8912    sing\x20MessageLite\x20and\x20the\x20lite\x20runtime.\n\n\x0f\n\x07\x04\
8913    \n\x04\0\x02\x02\x01\x12\x04\xfe\x02\x04\x10\n\x0f\n\x07\x04\n\x04\0\x02\
8914    \x02\x02\x12\x04\xfe\x02\x13\x14\n\x0c\n\x04\x04\n\x02\x05\x12\x04\x80\
8915    \x03\x02;\n\r\n\x05\x04\n\x02\x05\x04\x12\x04\x80\x03\x02\n\n\r\n\x05\
8916    \x04\n\x02\x05\x06\x12\x04\x80\x03\x0b\x17\n\r\n\x05\x04\n\x02\x05\x01\
8917    \x12\x04\x80\x03\x18$\n\r\n\x05\x04\n\x02\x05\x03\x12\x04\x80\x03'(\n\r\
8918    \n\x05\x04\n\x02\x05\x08\x12\x04\x80\x03):\n\r\n\x05\x04\n\x02\x05\x07\
8919    \x12\x04\x80\x0349\n\xe2\x02\n\x04\x04\n\x02\x06\x12\x04\x87\x03\x02\"\
8920    \x1a\xd3\x02\x20Sets\x20the\x20Go\x20package\x20where\x20structs\x20gene\
8921    rated\x20from\x20this\x20.proto\x20will\x20be\n\x20placed.\x20If\x20omit\
8922    ted,\x20the\x20Go\x20package\x20will\x20be\x20derived\x20from\x20the\x20\
8923    following:\n\x20\x20\x20-\x20The\x20basename\x20of\x20the\x20package\x20\
8924    import\x20path,\x20if\x20provided.\n\x20\x20\x20-\x20Otherwise,\x20the\
8925    \x20package\x20statement\x20in\x20the\x20.proto\x20file,\x20if\x20presen\
8926    t.\n\x20\x20\x20-\x20Otherwise,\x20the\x20basename\x20of\x20the\x20.prot\
8927    o\x20file,\x20without\x20extension.\n\n\r\n\x05\x04\n\x02\x06\x04\x12\
8928    \x04\x87\x03\x02\n\n\r\n\x05\x04\n\x02\x06\x05\x12\x04\x87\x03\x0b\x11\n\
8929    \r\n\x05\x04\n\x02\x06\x01\x12\x04\x87\x03\x12\x1c\n\r\n\x05\x04\n\x02\
8930    \x06\x03\x12\x04\x87\x03\x1f!\n\xd4\x04\n\x04\x04\n\x02\x07\x12\x04\x96\
8931    \x03\x02;\x1a\xc5\x04\x20Should\x20generic\x20services\x20be\x20generate\
8932    d\x20in\x20each\x20language?\x20\x20\"Generic\"\x20services\n\x20are\x20\
8933    not\x20specific\x20to\x20any\x20particular\x20RPC\x20system.\x20\x20They\
8934    \x20are\x20generated\x20by\x20the\n\x20main\x20code\x20generators\x20in\
8935    \x20each\x20language\x20(without\x20additional\x20plugins).\n\x20Generic\
8936    \x20services\x20were\x20the\x20only\x20kind\x20of\x20service\x20generati\
8937    on\x20supported\x20by\n\x20early\x20versions\x20of\x20google.protobuf.\n\
8938    \n\x20Generic\x20services\x20are\x20now\x20considered\x20deprecated\x20i\
8939    n\x20favor\x20of\x20using\x20plugins\n\x20that\x20generate\x20code\x20sp\
8940    ecific\x20to\x20your\x20particular\x20RPC\x20system.\x20\x20Therefore,\n\
8941    \x20these\x20default\x20to\x20false.\x20\x20Old\x20code\x20which\x20depe\
8942    nds\x20on\x20generic\x20services\x20should\n\x20explicitly\x20set\x20the\
8943    m\x20to\x20true.\n\n\r\n\x05\x04\n\x02\x07\x04\x12\x04\x96\x03\x02\n\n\r\
8944    \n\x05\x04\n\x02\x07\x05\x12\x04\x96\x03\x0b\x0f\n\r\n\x05\x04\n\x02\x07\
8945    \x01\x12\x04\x96\x03\x10#\n\r\n\x05\x04\n\x02\x07\x03\x12\x04\x96\x03&(\
8946    \n\r\n\x05\x04\n\x02\x07\x08\x12\x04\x96\x03):\n\r\n\x05\x04\n\x02\x07\
8947    \x07\x12\x04\x96\x0349\n\x0c\n\x04\x04\n\x02\x08\x12\x04\x97\x03\x02=\n\
8948    \r\n\x05\x04\n\x02\x08\x04\x12\x04\x97\x03\x02\n\n\r\n\x05\x04\n\x02\x08\
8949    \x05\x12\x04\x97\x03\x0b\x0f\n\r\n\x05\x04\n\x02\x08\x01\x12\x04\x97\x03\
8950    \x10%\n\r\n\x05\x04\n\x02\x08\x03\x12\x04\x97\x03(*\n\r\n\x05\x04\n\x02\
8951    \x08\x08\x12\x04\x97\x03+<\n\r\n\x05\x04\n\x02\x08\x07\x12\x04\x97\x036;\
8952    \n\x0c\n\x04\x04\n\x02\t\x12\x04\x98\x03\x02;\n\r\n\x05\x04\n\x02\t\x04\
8953    \x12\x04\x98\x03\x02\n\n\r\n\x05\x04\n\x02\t\x05\x12\x04\x98\x03\x0b\x0f\
8954    \n\r\n\x05\x04\n\x02\t\x01\x12\x04\x98\x03\x10#\n\r\n\x05\x04\n\x02\t\
8955    \x03\x12\x04\x98\x03&(\n\r\n\x05\x04\n\x02\t\x08\x12\x04\x98\x03):\n\r\n\
8956    \x05\x04\n\x02\t\x07\x12\x04\x98\x0349\n\x0c\n\x04\x04\n\x02\n\x12\x04\
8957    \x99\x03\x02<\n\r\n\x05\x04\n\x02\n\x04\x12\x04\x99\x03\x02\n\n\r\n\x05\
8958    \x04\n\x02\n\x05\x12\x04\x99\x03\x0b\x0f\n\r\n\x05\x04\n\x02\n\x01\x12\
8959    \x04\x99\x03\x10$\n\r\n\x05\x04\n\x02\n\x03\x12\x04\x99\x03')\n\r\n\x05\
8960    \x04\n\x02\n\x08\x12\x04\x99\x03*;\n\r\n\x05\x04\n\x02\n\x07\x12\x04\x99\
8961    \x035:\n\xf3\x01\n\x04\x04\n\x02\x0b\x12\x04\x9f\x03\x022\x1a\xe4\x01\
8962    \x20Is\x20this\x20file\x20deprecated?\n\x20Depending\x20on\x20the\x20tar\
8963    get\x20platform,\x20this\x20can\x20emit\x20Deprecated\x20annotations\n\
8964    \x20for\x20everything\x20in\x20the\x20file,\x20or\x20it\x20will\x20be\
8965    \x20completely\x20ignored;\x20in\x20the\x20very\n\x20least,\x20this\x20i\
8966    s\x20a\x20formalization\x20for\x20deprecating\x20files.\n\n\r\n\x05\x04\
8967    \n\x02\x0b\x04\x12\x04\x9f\x03\x02\n\n\r\n\x05\x04\n\x02\x0b\x05\x12\x04\
8968    \x9f\x03\x0b\x0f\n\r\n\x05\x04\n\x02\x0b\x01\x12\x04\x9f\x03\x10\x1a\n\r\
8969    \n\x05\x04\n\x02\x0b\x03\x12\x04\x9f\x03\x1d\x1f\n\r\n\x05\x04\n\x02\x0b\
8970    \x08\x12\x04\x9f\x03\x201\n\r\n\x05\x04\n\x02\x0b\x07\x12\x04\x9f\x03+0\
8971    \n\x7f\n\x04\x04\n\x02\x0c\x12\x04\xa3\x03\x027\x1aq\x20Enables\x20the\
8972    \x20use\x20of\x20arenas\x20for\x20the\x20proto\x20messages\x20in\x20this\
8973    \x20file.\x20This\x20applies\n\x20only\x20to\x20generated\x20classes\x20\
8974    for\x20C++.\n\n\r\n\x05\x04\n\x02\x0c\x04\x12\x04\xa3\x03\x02\n\n\r\n\
8975    \x05\x04\n\x02\x0c\x05\x12\x04\xa3\x03\x0b\x0f\n\r\n\x05\x04\n\x02\x0c\
8976    \x01\x12\x04\xa3\x03\x10\x20\n\r\n\x05\x04\n\x02\x0c\x03\x12\x04\xa3\x03\
8977    #%\n\r\n\x05\x04\n\x02\x0c\x08\x12\x04\xa3\x03&6\n\r\n\x05\x04\n\x02\x0c\
8978    \x07\x12\x04\xa3\x0315\n\x92\x01\n\x04\x04\n\x02\r\x12\x04\xa8\x03\x02)\
8979    \x1a\x83\x01\x20Sets\x20the\x20objective\x20c\x20class\x20prefix\x20whic\
8980    h\x20is\x20prepended\x20to\x20all\x20objective\x20c\n\x20generated\x20cl\
8981    asses\x20from\x20this\x20.proto.\x20There\x20is\x20no\x20default.\n\n\r\
8982    \n\x05\x04\n\x02\r\x04\x12\x04\xa8\x03\x02\n\n\r\n\x05\x04\n\x02\r\x05\
8983    \x12\x04\xa8\x03\x0b\x11\n\r\n\x05\x04\n\x02\r\x01\x12\x04\xa8\x03\x12#\
8984    \n\r\n\x05\x04\n\x02\r\x03\x12\x04\xa8\x03&(\nI\n\x04\x04\n\x02\x0e\x12\
8985    \x04\xab\x03\x02(\x1a;\x20Namespace\x20for\x20generated\x20classes;\x20d\
8986    efaults\x20to\x20the\x20package.\n\n\r\n\x05\x04\n\x02\x0e\x04\x12\x04\
8987    \xab\x03\x02\n\n\r\n\x05\x04\n\x02\x0e\x05\x12\x04\xab\x03\x0b\x11\n\r\n\
8988    \x05\x04\n\x02\x0e\x01\x12\x04\xab\x03\x12\"\n\r\n\x05\x04\n\x02\x0e\x03\
8989    \x12\x04\xab\x03%'\n\x91\x02\n\x04\x04\n\x02\x0f\x12\x04\xb1\x03\x02$\
8990    \x1a\x82\x02\x20By\x20default\x20Swift\x20generators\x20will\x20take\x20\
8991    the\x20proto\x20package\x20and\x20CamelCase\x20it\n\x20replacing\x20'.'\
8992    \x20with\x20underscore\x20and\x20use\x20that\x20to\x20prefix\x20the\x20t\
8993    ypes/symbols\n\x20defined.\x20When\x20this\x20options\x20is\x20provided,\
8994    \x20they\x20will\x20use\x20this\x20value\x20instead\n\x20to\x20prefix\
8995    \x20the\x20types/symbols\x20defined.\n\n\r\n\x05\x04\n\x02\x0f\x04\x12\
8996    \x04\xb1\x03\x02\n\n\r\n\x05\x04\n\x02\x0f\x05\x12\x04\xb1\x03\x0b\x11\n\
8997    \r\n\x05\x04\n\x02\x0f\x01\x12\x04\xb1\x03\x12\x1e\n\r\n\x05\x04\n\x02\
8998    \x0f\x03\x12\x04\xb1\x03!#\n~\n\x04\x04\n\x02\x10\x12\x04\xb5\x03\x02(\
8999    \x1ap\x20Sets\x20the\x20php\x20class\x20prefix\x20which\x20is\x20prepend\
9000    ed\x20to\x20all\x20php\x20generated\x20classes\n\x20from\x20this\x20.pro\
9001    to.\x20Default\x20is\x20empty.\n\n\r\n\x05\x04\n\x02\x10\x04\x12\x04\xb5\
9002    \x03\x02\n\n\r\n\x05\x04\n\x02\x10\x05\x12\x04\xb5\x03\x0b\x11\n\r\n\x05\
9003    \x04\n\x02\x10\x01\x12\x04\xb5\x03\x12\"\n\r\n\x05\x04\n\x02\x10\x03\x12\
9004    \x04\xb5\x03%'\n\xbe\x01\n\x04\x04\n\x02\x11\x12\x04\xba\x03\x02%\x1a\
9005    \xaf\x01\x20Use\x20this\x20option\x20to\x20change\x20the\x20namespace\
9006    \x20of\x20php\x20generated\x20classes.\x20Default\n\x20is\x20empty.\x20W\
9007    hen\x20this\x20option\x20is\x20empty,\x20the\x20package\x20name\x20will\
9008    \x20be\x20used\x20for\n\x20determining\x20the\x20namespace.\n\n\r\n\x05\
9009    \x04\n\x02\x11\x04\x12\x04\xba\x03\x02\n\n\r\n\x05\x04\n\x02\x11\x05\x12\
9010    \x04\xba\x03\x0b\x11\n\r\n\x05\x04\n\x02\x11\x01\x12\x04\xba\x03\x12\x1f\
9011    \n\r\n\x05\x04\n\x02\x11\x03\x12\x04\xba\x03\"$\n\xca\x01\n\x04\x04\n\
9012    \x02\x12\x12\x04\xbf\x03\x02.\x1a\xbb\x01\x20Use\x20this\x20option\x20to\
9013    \x20change\x20the\x20namespace\x20of\x20php\x20generated\x20metadata\x20\
9014    classes.\n\x20Default\x20is\x20empty.\x20When\x20this\x20option\x20is\
9015    \x20empty,\x20the\x20proto\x20file\x20name\x20will\x20be\n\x20used\x20fo\
9016    r\x20determining\x20the\x20namespace.\n\n\r\n\x05\x04\n\x02\x12\x04\x12\
9017    \x04\xbf\x03\x02\n\n\r\n\x05\x04\n\x02\x12\x05\x12\x04\xbf\x03\x0b\x11\n\
9018    \r\n\x05\x04\n\x02\x12\x01\x12\x04\xbf\x03\x12(\n\r\n\x05\x04\n\x02\x12\
9019    \x03\x12\x04\xbf\x03+-\n\xc2\x01\n\x04\x04\n\x02\x13\x12\x04\xc4\x03\x02\
9020    $\x1a\xb3\x01\x20Use\x20this\x20option\x20to\x20change\x20the\x20package\
9021    \x20of\x20ruby\x20generated\x20classes.\x20Default\n\x20is\x20empty.\x20\
9022    When\x20this\x20option\x20is\x20not\x20set,\x20the\x20package\x20name\
9023    \x20will\x20be\x20used\x20for\n\x20determining\x20the\x20ruby\x20package\
9024    .\n\n\r\n\x05\x04\n\x02\x13\x04\x12\x04\xc4\x03\x02\n\n\r\n\x05\x04\n\
9025    \x02\x13\x05\x12\x04\xc4\x03\x0b\x11\n\r\n\x05\x04\n\x02\x13\x01\x12\x04\
9026    \xc4\x03\x12\x1e\n\r\n\x05\x04\n\x02\x13\x03\x12\x04\xc4\x03!#\n|\n\x04\
9027    \x04\n\x02\x14\x12\x04\xc9\x03\x02:\x1an\x20The\x20parser\x20stores\x20o\
9028    ptions\x20it\x20doesn't\x20recognize\x20here.\n\x20See\x20the\x20documen\
9029    tation\x20for\x20the\x20\"Options\"\x20section\x20above.\n\n\r\n\x05\x04\
9030    \n\x02\x14\x04\x12\x04\xc9\x03\x02\n\n\r\n\x05\x04\n\x02\x14\x06\x12\x04\
9031    \xc9\x03\x0b\x1e\n\r\n\x05\x04\n\x02\x14\x01\x12\x04\xc9\x03\x1f3\n\r\n\
9032    \x05\x04\n\x02\x14\x03\x12\x04\xc9\x0369\n\x87\x01\n\x03\x04\n\x05\x12\
9033    \x04\xcd\x03\x02\x19\x1az\x20Clients\x20can\x20define\x20custom\x20optio\
9034    ns\x20in\x20extensions\x20of\x20this\x20message.\n\x20See\x20the\x20docu\
9035    mentation\x20for\x20the\x20\"Options\"\x20section\x20above.\n\n\x0c\n\
9036    \x04\x04\n\x05\0\x12\x04\xcd\x03\r\x18\n\r\n\x05\x04\n\x05\0\x01\x12\x04\
9037    \xcd\x03\r\x11\n\r\n\x05\x04\n\x05\0\x02\x12\x04\xcd\x03\x15\x18\n\x0b\n\
9038    \x03\x04\n\t\x12\x04\xcf\x03\x02\x0e\n\x0c\n\x04\x04\n\t\0\x12\x04\xcf\
9039    \x03\x0b\r\n\r\n\x05\x04\n\t\0\x01\x12\x04\xcf\x03\x0b\r\n\r\n\x05\x04\n\
9040    \t\0\x02\x12\x04\xcf\x03\x0b\r\n\x0c\n\x02\x04\x0b\x12\x06\xd2\x03\0\x94\
9041    \x04\x01\n\x0b\n\x03\x04\x0b\x01\x12\x04\xd2\x03\x08\x16\n\xd8\x05\n\x04\
9042    \x04\x0b\x02\0\x12\x04\xe5\x03\x02>\x1a\xc9\x05\x20Set\x20true\x20to\x20\
9043    use\x20the\x20old\x20proto1\x20MessageSet\x20wire\x20format\x20for\x20ex\
9044    tensions.\n\x20This\x20is\x20provided\x20for\x20backwards-compatibility\
9045    \x20with\x20the\x20MessageSet\x20wire\n\x20format.\x20\x20You\x20should\
9046    \x20not\x20use\x20this\x20for\x20any\x20other\x20reason:\x20\x20It's\x20\
9047    less\n\x20efficient,\x20has\x20fewer\x20features,\x20and\x20is\x20more\
9048    \x20complicated.\n\n\x20The\x20message\x20must\x20be\x20defined\x20exact\
9049    ly\x20as\x20follows:\n\x20\x20\x20message\x20Foo\x20{\n\x20\x20\x20\x20\
9050    \x20option\x20message_set_wire_format\x20=\x20true;\n\x20\x20\x20\x20\
9051    \x20extensions\x204\x20to\x20max;\n\x20\x20\x20}\n\x20Note\x20that\x20th\
9052    e\x20message\x20cannot\x20have\x20any\x20defined\x20fields;\x20MessageSe\
9053    ts\x20only\n\x20have\x20extensions.\n\n\x20All\x20extensions\x20of\x20yo\
9054    ur\x20type\x20must\x20be\x20singular\x20messages;\x20e.g.\x20they\x20can\
9055    not\n\x20be\x20int32s,\x20enums,\x20or\x20repeated\x20messages.\n\n\x20B\
9056    ecause\x20this\x20is\x20an\x20option,\x20the\x20above\x20two\x20restrict\
9057    ions\x20are\x20not\x20enforced\x20by\n\x20the\x20protocol\x20compiler.\n\
9058    \n\r\n\x05\x04\x0b\x02\0\x04\x12\x04\xe5\x03\x02\n\n\r\n\x05\x04\x0b\x02\
9059    \0\x05\x12\x04\xe5\x03\x0b\x0f\n\r\n\x05\x04\x0b\x02\0\x01\x12\x04\xe5\
9060    \x03\x10'\n\r\n\x05\x04\x0b\x02\0\x03\x12\x04\xe5\x03*+\n\r\n\x05\x04\
9061    \x0b\x02\0\x08\x12\x04\xe5\x03,=\n\r\n\x05\x04\x0b\x02\0\x07\x12\x04\xe5\
9062    \x037<\n\xeb\x01\n\x04\x04\x0b\x02\x01\x12\x04\xea\x03\x02F\x1a\xdc\x01\
9063    \x20Disables\x20the\x20generation\x20of\x20the\x20standard\x20\"descript\
9064    or()\"\x20accessor,\x20which\x20can\n\x20conflict\x20with\x20a\x20field\
9065    \x20of\x20the\x20same\x20name.\x20\x20This\x20is\x20meant\x20to\x20make\
9066    \x20migration\n\x20from\x20proto1\x20easier;\x20new\x20code\x20should\
9067    \x20avoid\x20fields\x20named\x20\"descriptor\".\n\n\r\n\x05\x04\x0b\x02\
9068    \x01\x04\x12\x04\xea\x03\x02\n\n\r\n\x05\x04\x0b\x02\x01\x05\x12\x04\xea\
9069    \x03\x0b\x0f\n\r\n\x05\x04\x0b\x02\x01\x01\x12\x04\xea\x03\x10/\n\r\n\
9070    \x05\x04\x0b\x02\x01\x03\x12\x04\xea\x0323\n\r\n\x05\x04\x0b\x02\x01\x08\
9071    \x12\x04\xea\x034E\n\r\n\x05\x04\x0b\x02\x01\x07\x12\x04\xea\x03?D\n\xee\
9072    \x01\n\x04\x04\x0b\x02\x02\x12\x04\xf0\x03\x021\x1a\xdf\x01\x20Is\x20thi\
9073    s\x20message\x20deprecated?\n\x20Depending\x20on\x20the\x20target\x20pla\
9074    tform,\x20this\x20can\x20emit\x20Deprecated\x20annotations\n\x20for\x20t\
9075    he\x20message,\x20or\x20it\x20will\x20be\x20completely\x20ignored;\x20in\
9076    \x20the\x20very\x20least,\n\x20this\x20is\x20a\x20formalization\x20for\
9077    \x20deprecating\x20messages.\n\n\r\n\x05\x04\x0b\x02\x02\x04\x12\x04\xf0\
9078    \x03\x02\n\n\r\n\x05\x04\x0b\x02\x02\x05\x12\x04\xf0\x03\x0b\x0f\n\r\n\
9079    \x05\x04\x0b\x02\x02\x01\x12\x04\xf0\x03\x10\x1a\n\r\n\x05\x04\x0b\x02\
9080    \x02\x03\x12\x04\xf0\x03\x1d\x1e\n\r\n\x05\x04\x0b\x02\x02\x08\x12\x04\
9081    \xf0\x03\x1f0\n\r\n\x05\x04\x0b\x02\x02\x07\x12\x04\xf0\x03*/\n\x0b\n\
9082    \x03\x04\x0b\t\x12\x04\xf2\x03\x02\x13\n\x0c\n\x04\x04\x0b\t\0\x12\x04\
9083    \xf2\x03\x0b\x0c\n\r\n\x05\x04\x0b\t\0\x01\x12\x04\xf2\x03\x0b\x0c\n\r\n\
9084    \x05\x04\x0b\t\0\x02\x12\x04\xf2\x03\x0b\x0c\n\x0c\n\x04\x04\x0b\t\x01\
9085    \x12\x04\xf2\x03\x0e\x0f\n\r\n\x05\x04\x0b\t\x01\x01\x12\x04\xf2\x03\x0e\
9086    \x0f\n\r\n\x05\x04\x0b\t\x01\x02\x12\x04\xf2\x03\x0e\x0f\n\x0c\n\x04\x04\
9087    \x0b\t\x02\x12\x04\xf2\x03\x11\x12\n\r\n\x05\x04\x0b\t\x02\x01\x12\x04\
9088    \xf2\x03\x11\x12\n\r\n\x05\x04\x0b\t\x02\x02\x12\x04\xf2\x03\x11\x12\n\
9089    \xa0\x06\n\x04\x04\x0b\x02\x03\x12\x04\x89\x04\x02\x1e\x1a\x91\x06\x20Wh\
9090    ether\x20the\x20message\x20is\x20an\x20automatically\x20generated\x20map\
9091    \x20entry\x20type\x20for\x20the\n\x20maps\x20field.\n\n\x20For\x20maps\
9092    \x20fields:\n\x20\x20\x20\x20\x20map<KeyType,\x20ValueType>\x20map_field\
9093    \x20=\x201;\n\x20The\x20parsed\x20descriptor\x20looks\x20like:\n\x20\x20\
9094    \x20\x20\x20message\x20MapFieldEntry\x20{\n\x20\x20\x20\x20\x20\x20\x20\
9095    \x20\x20option\x20map_entry\x20=\x20true;\n\x20\x20\x20\x20\x20\x20\x20\
9096    \x20\x20optional\x20KeyType\x20key\x20=\x201;\n\x20\x20\x20\x20\x20\x20\
9097    \x20\x20\x20optional\x20ValueType\x20value\x20=\x202;\n\x20\x20\x20\x20\
9098    \x20}\n\x20\x20\x20\x20\x20repeated\x20MapFieldEntry\x20map_field\x20=\
9099    \x201;\n\n\x20Implementations\x20may\x20choose\x20not\x20to\x20generate\
9100    \x20the\x20map_entry=true\x20message,\x20but\n\x20use\x20a\x20native\x20\
9101    map\x20in\x20the\x20target\x20language\x20to\x20hold\x20the\x20keys\x20a\
9102    nd\x20values.\n\x20The\x20reflection\x20APIs\x20in\x20such\x20implementa\
9103    tions\x20still\x20need\x20to\x20work\x20as\n\x20if\x20the\x20field\x20is\
9104    \x20a\x20repeated\x20message\x20field.\n\n\x20NOTE:\x20Do\x20not\x20set\
9105    \x20the\x20option\x20in\x20.proto\x20files.\x20Always\x20use\x20the\x20m\
9106    aps\x20syntax\n\x20instead.\x20The\x20option\x20should\x20only\x20be\x20\
9107    implicitly\x20set\x20by\x20the\x20proto\x20compiler\n\x20parser.\n\n\r\n\
9108    \x05\x04\x0b\x02\x03\x04\x12\x04\x89\x04\x02\n\n\r\n\x05\x04\x0b\x02\x03\
9109    \x05\x12\x04\x89\x04\x0b\x0f\n\r\n\x05\x04\x0b\x02\x03\x01\x12\x04\x89\
9110    \x04\x10\x19\n\r\n\x05\x04\x0b\x02\x03\x03\x12\x04\x89\x04\x1c\x1d\n$\n\
9111    \x03\x04\x0b\t\x12\x04\x8b\x04\x02\r\"\x17\x20javalite_serializable\n\n\
9112    \x0c\n\x04\x04\x0b\t\x03\x12\x04\x8b\x04\x0b\x0c\n\r\n\x05\x04\x0b\t\x03\
9113    \x01\x12\x04\x8b\x04\x0b\x0c\n\r\n\x05\x04\x0b\t\x03\x02\x12\x04\x8b\x04\
9114    \x0b\x0c\n\x1f\n\x03\x04\x0b\t\x12\x04\x8c\x04\x02\r\"\x12\x20javanano_a\
9115    s_lite\n\n\x0c\n\x04\x04\x0b\t\x04\x12\x04\x8c\x04\x0b\x0c\n\r\n\x05\x04\
9116    \x0b\t\x04\x01\x12\x04\x8c\x04\x0b\x0c\n\r\n\x05\x04\x0b\t\x04\x02\x12\
9117    \x04\x8c\x04\x0b\x0c\nO\n\x04\x04\x0b\x02\x04\x12\x04\x90\x04\x02:\x1aA\
9118    \x20The\x20parser\x20stores\x20options\x20it\x20doesn't\x20recognize\x20\
9119    here.\x20See\x20above.\n\n\r\n\x05\x04\x0b\x02\x04\x04\x12\x04\x90\x04\
9120    \x02\n\n\r\n\x05\x04\x0b\x02\x04\x06\x12\x04\x90\x04\x0b\x1e\n\r\n\x05\
9121    \x04\x0b\x02\x04\x01\x12\x04\x90\x04\x1f3\n\r\n\x05\x04\x0b\x02\x04\x03\
9122    \x12\x04\x90\x0469\nZ\n\x03\x04\x0b\x05\x12\x04\x93\x04\x02\x19\x1aM\x20\
9123    Clients\x20can\x20define\x20custom\x20options\x20in\x20extensions\x20of\
9124    \x20this\x20message.\x20See\x20above.\n\n\x0c\n\x04\x04\x0b\x05\0\x12\
9125    \x04\x93\x04\r\x18\n\r\n\x05\x04\x0b\x05\0\x01\x12\x04\x93\x04\r\x11\n\r\
9126    \n\x05\x04\x0b\x05\0\x02\x12\x04\x93\x04\x15\x18\n\x0c\n\x02\x04\x0c\x12\
9127    \x06\x96\x04\0\xf1\x04\x01\n\x0b\n\x03\x04\x0c\x01\x12\x04\x96\x04\x08\
9128    \x14\n\xa3\x02\n\x04\x04\x0c\x02\0\x12\x04\x9b\x04\x02.\x1a\x94\x02\x20T\
9129    he\x20ctype\x20option\x20instructs\x20the\x20C++\x20code\x20generator\
9130    \x20to\x20use\x20a\x20different\n\x20representation\x20of\x20the\x20fiel\
9131    d\x20than\x20it\x20normally\x20would.\x20\x20See\x20the\x20specific\n\
9132    \x20options\x20below.\x20\x20This\x20option\x20is\x20not\x20yet\x20imple\
9133    mented\x20in\x20the\x20open\x20source\n\x20release\x20--\x20sorry,\x20we\
9134    'll\x20try\x20to\x20include\x20it\x20in\x20a\x20future\x20version!\n\n\r\
9135    \n\x05\x04\x0c\x02\0\x04\x12\x04\x9b\x04\x02\n\n\r\n\x05\x04\x0c\x02\0\
9136    \x06\x12\x04\x9b\x04\x0b\x10\n\r\n\x05\x04\x0c\x02\0\x01\x12\x04\x9b\x04\
9137    \x11\x16\n\r\n\x05\x04\x0c\x02\0\x03\x12\x04\x9b\x04\x19\x1a\n\r\n\x05\
9138    \x04\x0c\x02\0\x08\x12\x04\x9b\x04\x1b-\n\r\n\x05\x04\x0c\x02\0\x07\x12\
9139    \x04\x9b\x04&,\n\x0e\n\x04\x04\x0c\x04\0\x12\x06\x9c\x04\x02\xa3\x04\x03\
9140    \n\r\n\x05\x04\x0c\x04\0\x01\x12\x04\x9c\x04\x07\x0c\n\x1f\n\x06\x04\x0c\
9141    \x04\0\x02\0\x12\x04\x9e\x04\x04\x0f\x1a\x0f\x20Default\x20mode.\n\n\x0f\
9142    \n\x07\x04\x0c\x04\0\x02\0\x01\x12\x04\x9e\x04\x04\n\n\x0f\n\x07\x04\x0c\
9143    \x04\0\x02\0\x02\x12\x04\x9e\x04\r\x0e\n\x0e\n\x06\x04\x0c\x04\0\x02\x01\
9144    \x12\x04\xa0\x04\x04\r\n\x0f\n\x07\x04\x0c\x04\0\x02\x01\x01\x12\x04\xa0\
9145    \x04\x04\x08\n\x0f\n\x07\x04\x0c\x04\0\x02\x01\x02\x12\x04\xa0\x04\x0b\
9146    \x0c\n\x0e\n\x06\x04\x0c\x04\0\x02\x02\x12\x04\xa2\x04\x04\x15\n\x0f\n\
9147    \x07\x04\x0c\x04\0\x02\x02\x01\x12\x04\xa2\x04\x04\x10\n\x0f\n\x07\x04\
9148    \x0c\x04\0\x02\x02\x02\x12\x04\xa2\x04\x13\x14\n\xda\x02\n\x04\x04\x0c\
9149    \x02\x01\x12\x04\xa9\x04\x02\x1b\x1a\xcb\x02\x20The\x20packed\x20option\
9150    \x20can\x20be\x20enabled\x20for\x20repeated\x20primitive\x20fields\x20to\
9151    \x20enable\n\x20a\x20more\x20efficient\x20representation\x20on\x20the\
9152    \x20wire.\x20Rather\x20than\x20repeatedly\n\x20writing\x20the\x20tag\x20\
9153    and\x20type\x20for\x20each\x20element,\x20the\x20entire\x20array\x20is\
9154    \x20encoded\x20as\n\x20a\x20single\x20length-delimited\x20blob.\x20In\
9155    \x20proto3,\x20only\x20explicit\x20setting\x20it\x20to\n\x20false\x20wil\
9156    l\x20avoid\x20using\x20packed\x20encoding.\n\n\r\n\x05\x04\x0c\x02\x01\
9157    \x04\x12\x04\xa9\x04\x02\n\n\r\n\x05\x04\x0c\x02\x01\x05\x12\x04\xa9\x04\
9158    \x0b\x0f\n\r\n\x05\x04\x0c\x02\x01\x01\x12\x04\xa9\x04\x10\x16\n\r\n\x05\
9159    \x04\x0c\x02\x01\x03\x12\x04\xa9\x04\x19\x1a\n\x9a\x05\n\x04\x04\x0c\x02\
9160    \x02\x12\x04\xb6\x04\x023\x1a\x8b\x05\x20The\x20jstype\x20option\x20dete\
9161    rmines\x20the\x20JavaScript\x20type\x20used\x20for\x20values\x20of\x20th\
9162    e\n\x20field.\x20\x20The\x20option\x20is\x20permitted\x20only\x20for\x20\
9163    64\x20bit\x20integral\x20and\x20fixed\x20types\n\x20(int64,\x20uint64,\
9164    \x20sint64,\x20fixed64,\x20sfixed64).\x20\x20A\x20field\x20with\x20jstyp\
9165    e\x20JS_STRING\n\x20is\x20represented\x20as\x20JavaScript\x20string,\x20\
9166    which\x20avoids\x20loss\x20of\x20precision\x20that\n\x20can\x20happen\
9167    \x20when\x20a\x20large\x20value\x20is\x20converted\x20to\x20a\x20floatin\
9168    g\x20point\x20JavaScript.\n\x20Specifying\x20JS_NUMBER\x20for\x20the\x20\
9169    jstype\x20causes\x20the\x20generated\x20JavaScript\x20code\x20to\n\x20us\
9170    e\x20the\x20JavaScript\x20\"number\"\x20type.\x20\x20The\x20behavior\x20\
9171    of\x20the\x20default\x20option\n\x20JS_NORMAL\x20is\x20implementation\
9172    \x20dependent.\n\n\x20This\x20option\x20is\x20an\x20enum\x20to\x20permit\
9173    \x20additional\x20types\x20to\x20be\x20added,\x20e.g.\n\x20goog.math.Int\
9174    eger.\n\n\r\n\x05\x04\x0c\x02\x02\x04\x12\x04\xb6\x04\x02\n\n\r\n\x05\
9175    \x04\x0c\x02\x02\x06\x12\x04\xb6\x04\x0b\x11\n\r\n\x05\x04\x0c\x02\x02\
9176    \x01\x12\x04\xb6\x04\x12\x18\n\r\n\x05\x04\x0c\x02\x02\x03\x12\x04\xb6\
9177    \x04\x1b\x1c\n\r\n\x05\x04\x0c\x02\x02\x08\x12\x04\xb6\x04\x1d2\n\r\n\
9178    \x05\x04\x0c\x02\x02\x07\x12\x04\xb6\x04(1\n\x0e\n\x04\x04\x0c\x04\x01\
9179    \x12\x06\xb7\x04\x02\xc0\x04\x03\n\r\n\x05\x04\x0c\x04\x01\x01\x12\x04\
9180    \xb7\x04\x07\r\n'\n\x06\x04\x0c\x04\x01\x02\0\x12\x04\xb9\x04\x04\x12\
9181    \x1a\x17\x20Use\x20the\x20default\x20type.\n\n\x0f\n\x07\x04\x0c\x04\x01\
9182    \x02\0\x01\x12\x04\xb9\x04\x04\r\n\x0f\n\x07\x04\x0c\x04\x01\x02\0\x02\
9183    \x12\x04\xb9\x04\x10\x11\n)\n\x06\x04\x0c\x04\x01\x02\x01\x12\x04\xbc\
9184    \x04\x04\x12\x1a\x19\x20Use\x20JavaScript\x20strings.\n\n\x0f\n\x07\x04\
9185    \x0c\x04\x01\x02\x01\x01\x12\x04\xbc\x04\x04\r\n\x0f\n\x07\x04\x0c\x04\
9186    \x01\x02\x01\x02\x12\x04\xbc\x04\x10\x11\n)\n\x06\x04\x0c\x04\x01\x02\
9187    \x02\x12\x04\xbf\x04\x04\x12\x1a\x19\x20Use\x20JavaScript\x20numbers.\n\
9188    \n\x0f\n\x07\x04\x0c\x04\x01\x02\x02\x01\x12\x04\xbf\x04\x04\r\n\x0f\n\
9189    \x07\x04\x0c\x04\x01\x02\x02\x02\x12\x04\xbf\x04\x10\x11\n\xef\x0c\n\x04\
9190    \x04\x0c\x02\x03\x12\x04\xde\x04\x02+\x1a\xe0\x0c\x20Should\x20this\x20f\
9191    ield\x20be\x20parsed\x20lazily?\x20\x20Lazy\x20applies\x20only\x20to\x20\
9192    message-type\n\x20fields.\x20\x20It\x20means\x20that\x20when\x20the\x20o\
9193    uter\x20message\x20is\x20initially\x20parsed,\x20the\n\x20inner\x20messa\
9194    ge's\x20contents\x20will\x20not\x20be\x20parsed\x20but\x20instead\x20sto\
9195    red\x20in\x20encoded\n\x20form.\x20\x20The\x20inner\x20message\x20will\
9196    \x20actually\x20be\x20parsed\x20when\x20it\x20is\x20first\x20accessed.\n\
9197    \n\x20This\x20is\x20only\x20a\x20hint.\x20\x20Implementations\x20are\x20\
9198    free\x20to\x20choose\x20whether\x20to\x20use\n\x20eager\x20or\x20lazy\
9199    \x20parsing\x20regardless\x20of\x20the\x20value\x20of\x20this\x20option.\
9200    \x20\x20However,\n\x20setting\x20this\x20option\x20true\x20suggests\x20t\
9201    hat\x20the\x20protocol\x20author\x20believes\x20that\n\x20using\x20lazy\
9202    \x20parsing\x20on\x20this\x20field\x20is\x20worth\x20the\x20additional\
9203    \x20bookkeeping\n\x20overhead\x20typically\x20needed\x20to\x20implement\
9204    \x20it.\n\n\x20This\x20option\x20does\x20not\x20affect\x20the\x20public\
9205    \x20interface\x20of\x20any\x20generated\x20code;\n\x20all\x20method\x20s\
9206    ignatures\x20remain\x20the\x20same.\x20\x20Furthermore,\x20thread-safety\
9207    \x20of\x20the\n\x20interface\x20is\x20not\x20affected\x20by\x20this\x20o\
9208    ption;\x20const\x20methods\x20remain\x20safe\x20to\n\x20call\x20from\x20\
9209    multiple\x20threads\x20concurrently,\x20while\x20non-const\x20methods\
9210    \x20continue\n\x20to\x20require\x20exclusive\x20access.\n\n\n\x20Note\
9211    \x20that\x20implementations\x20may\x20choose\x20not\x20to\x20check\x20re\
9212    quired\x20fields\x20within\n\x20a\x20lazy\x20sub-message.\x20\x20That\
9213    \x20is,\x20calling\x20IsInitialized()\x20on\x20the\x20outer\x20message\n\
9214    \x20may\x20return\x20true\x20even\x20if\x20the\x20inner\x20message\x20ha\
9215    s\x20missing\x20required\x20fields.\n\x20This\x20is\x20necessary\x20beca\
9216    use\x20otherwise\x20the\x20inner\x20message\x20would\x20have\x20to\x20be\
9217    \n\x20parsed\x20in\x20order\x20to\x20perform\x20the\x20check,\x20defeati\
9218    ng\x20the\x20purpose\x20of\x20lazy\n\x20parsing.\x20\x20An\x20implementa\
9219    tion\x20which\x20chooses\x20not\x20to\x20check\x20required\x20fields\n\
9220    \x20must\x20be\x20consistent\x20about\x20it.\x20\x20That\x20is,\x20for\
9221    \x20any\x20particular\x20sub-message,\x20the\n\x20implementation\x20must\
9222    \x20either\x20*always*\x20check\x20its\x20required\x20fields,\x20or\x20*\
9223    never*\n\x20check\x20its\x20required\x20fields,\x20regardless\x20of\x20w\
9224    hether\x20or\x20not\x20the\x20message\x20has\n\x20been\x20parsed.\n\n\r\
9225    \n\x05\x04\x0c\x02\x03\x04\x12\x04\xde\x04\x02\n\n\r\n\x05\x04\x0c\x02\
9226    \x03\x05\x12\x04\xde\x04\x0b\x0f\n\r\n\x05\x04\x0c\x02\x03\x01\x12\x04\
9227    \xde\x04\x10\x14\n\r\n\x05\x04\x0c\x02\x03\x03\x12\x04\xde\x04\x17\x18\n\
9228    \r\n\x05\x04\x0c\x02\x03\x08\x12\x04\xde\x04\x19*\n\r\n\x05\x04\x0c\x02\
9229    \x03\x07\x12\x04\xde\x04$)\n\xe8\x01\n\x04\x04\x0c\x02\x04\x12\x04\xe4\
9230    \x04\x021\x1a\xd9\x01\x20Is\x20this\x20field\x20deprecated?\n\x20Dependi\
9231    ng\x20on\x20the\x20target\x20platform,\x20this\x20can\x20emit\x20Depreca\
9232    ted\x20annotations\n\x20for\x20accessors,\x20or\x20it\x20will\x20be\x20c\
9233    ompletely\x20ignored;\x20in\x20the\x20very\x20least,\x20this\n\x20is\x20\
9234    a\x20formalization\x20for\x20deprecating\x20fields.\n\n\r\n\x05\x04\x0c\
9235    \x02\x04\x04\x12\x04\xe4\x04\x02\n\n\r\n\x05\x04\x0c\x02\x04\x05\x12\x04\
9236    \xe4\x04\x0b\x0f\n\r\n\x05\x04\x0c\x02\x04\x01\x12\x04\xe4\x04\x10\x1a\n\
9237    \r\n\x05\x04\x0c\x02\x04\x03\x12\x04\xe4\x04\x1d\x1e\n\r\n\x05\x04\x0c\
9238    \x02\x04\x08\x12\x04\xe4\x04\x1f0\n\r\n\x05\x04\x0c\x02\x04\x07\x12\x04\
9239    \xe4\x04*/\n?\n\x04\x04\x0c\x02\x05\x12\x04\xe7\x04\x02,\x1a1\x20For\x20\
9240    Google-internal\x20migration\x20only.\x20Do\x20not\x20use.\n\n\r\n\x05\
9241    \x04\x0c\x02\x05\x04\x12\x04\xe7\x04\x02\n\n\r\n\x05\x04\x0c\x02\x05\x05\
9242    \x12\x04\xe7\x04\x0b\x0f\n\r\n\x05\x04\x0c\x02\x05\x01\x12\x04\xe7\x04\
9243    \x10\x14\n\r\n\x05\x04\x0c\x02\x05\x03\x12\x04\xe7\x04\x17\x19\n\r\n\x05\
9244    \x04\x0c\x02\x05\x08\x12\x04\xe7\x04\x1a+\n\r\n\x05\x04\x0c\x02\x05\x07\
9245    \x12\x04\xe7\x04%*\nO\n\x04\x04\x0c\x02\x06\x12\x04\xeb\x04\x02:\x1aA\
9246    \x20The\x20parser\x20stores\x20options\x20it\x20doesn't\x20recognize\x20\
9247    here.\x20See\x20above.\n\n\r\n\x05\x04\x0c\x02\x06\x04\x12\x04\xeb\x04\
9248    \x02\n\n\r\n\x05\x04\x0c\x02\x06\x06\x12\x04\xeb\x04\x0b\x1e\n\r\n\x05\
9249    \x04\x0c\x02\x06\x01\x12\x04\xeb\x04\x1f3\n\r\n\x05\x04\x0c\x02\x06\x03\
9250    \x12\x04\xeb\x0469\nZ\n\x03\x04\x0c\x05\x12\x04\xee\x04\x02\x19\x1aM\x20\
9251    Clients\x20can\x20define\x20custom\x20options\x20in\x20extensions\x20of\
9252    \x20this\x20message.\x20See\x20above.\n\n\x0c\n\x04\x04\x0c\x05\0\x12\
9253    \x04\xee\x04\r\x18\n\r\n\x05\x04\x0c\x05\0\x01\x12\x04\xee\x04\r\x11\n\r\
9254    \n\x05\x04\x0c\x05\0\x02\x12\x04\xee\x04\x15\x18\n\x1c\n\x03\x04\x0c\t\
9255    \x12\x04\xf0\x04\x02\r\"\x0f\x20removed\x20jtype\n\n\x0c\n\x04\x04\x0c\t\
9256    \0\x12\x04\xf0\x04\x0b\x0c\n\r\n\x05\x04\x0c\t\0\x01\x12\x04\xf0\x04\x0b\
9257    \x0c\n\r\n\x05\x04\x0c\t\0\x02\x12\x04\xf0\x04\x0b\x0c\n\x0c\n\x02\x04\r\
9258    \x12\x06\xf3\x04\0\xf9\x04\x01\n\x0b\n\x03\x04\r\x01\x12\x04\xf3\x04\x08\
9259    \x14\nO\n\x04\x04\r\x02\0\x12\x04\xf5\x04\x02:\x1aA\x20The\x20parser\x20\
9260    stores\x20options\x20it\x20doesn't\x20recognize\x20here.\x20See\x20above\
9261    .\n\n\r\n\x05\x04\r\x02\0\x04\x12\x04\xf5\x04\x02\n\n\r\n\x05\x04\r\x02\
9262    \0\x06\x12\x04\xf5\x04\x0b\x1e\n\r\n\x05\x04\r\x02\0\x01\x12\x04\xf5\x04\
9263    \x1f3\n\r\n\x05\x04\r\x02\0\x03\x12\x04\xf5\x0469\nZ\n\x03\x04\r\x05\x12\
9264    \x04\xf8\x04\x02\x19\x1aM\x20Clients\x20can\x20define\x20custom\x20optio\
9265    ns\x20in\x20extensions\x20of\x20this\x20message.\x20See\x20above.\n\n\
9266    \x0c\n\x04\x04\r\x05\0\x12\x04\xf8\x04\r\x18\n\r\n\x05\x04\r\x05\0\x01\
9267    \x12\x04\xf8\x04\r\x11\n\r\n\x05\x04\r\x05\0\x02\x12\x04\xf8\x04\x15\x18\
9268    \n\x0c\n\x02\x04\x0e\x12\x06\xfb\x04\0\x8e\x05\x01\n\x0b\n\x03\x04\x0e\
9269    \x01\x12\x04\xfb\x04\x08\x13\n`\n\x04\x04\x0e\x02\0\x12\x04\xff\x04\x02\
9270    \x20\x1aR\x20Set\x20this\x20option\x20to\x20true\x20to\x20allow\x20mappi\
9271    ng\x20different\x20tag\x20names\x20to\x20the\x20same\n\x20value.\n\n\r\n\
9272    \x05\x04\x0e\x02\0\x04\x12\x04\xff\x04\x02\n\n\r\n\x05\x04\x0e\x02\0\x05\
9273    \x12\x04\xff\x04\x0b\x0f\n\r\n\x05\x04\x0e\x02\0\x01\x12\x04\xff\x04\x10\
9274    \x1b\n\r\n\x05\x04\x0e\x02\0\x03\x12\x04\xff\x04\x1e\x1f\n\xe5\x01\n\x04\
9275    \x04\x0e\x02\x01\x12\x04\x85\x05\x021\x1a\xd6\x01\x20Is\x20this\x20enum\
9276    \x20deprecated?\n\x20Depending\x20on\x20the\x20target\x20platform,\x20th\
9277    is\x20can\x20emit\x20Deprecated\x20annotations\n\x20for\x20the\x20enum,\
9278    \x20or\x20it\x20will\x20be\x20completely\x20ignored;\x20in\x20the\x20ver\
9279    y\x20least,\x20this\n\x20is\x20a\x20formalization\x20for\x20deprecating\
9280    \x20enums.\n\n\r\n\x05\x04\x0e\x02\x01\x04\x12\x04\x85\x05\x02\n\n\r\n\
9281    \x05\x04\x0e\x02\x01\x05\x12\x04\x85\x05\x0b\x0f\n\r\n\x05\x04\x0e\x02\
9282    \x01\x01\x12\x04\x85\x05\x10\x1a\n\r\n\x05\x04\x0e\x02\x01\x03\x12\x04\
9283    \x85\x05\x1d\x1e\n\r\n\x05\x04\x0e\x02\x01\x08\x12\x04\x85\x05\x1f0\n\r\
9284    \n\x05\x04\x0e\x02\x01\x07\x12\x04\x85\x05*/\n\x1f\n\x03\x04\x0e\t\x12\
9285    \x04\x87\x05\x02\r\"\x12\x20javanano_as_lite\n\n\x0c\n\x04\x04\x0e\t\0\
9286    \x12\x04\x87\x05\x0b\x0c\n\r\n\x05\x04\x0e\t\0\x01\x12\x04\x87\x05\x0b\
9287    \x0c\n\r\n\x05\x04\x0e\t\0\x02\x12\x04\x87\x05\x0b\x0c\nO\n\x04\x04\x0e\
9288    \x02\x02\x12\x04\x8a\x05\x02:\x1aA\x20The\x20parser\x20stores\x20options\
9289    \x20it\x20doesn't\x20recognize\x20here.\x20See\x20above.\n\n\r\n\x05\x04\
9290    \x0e\x02\x02\x04\x12\x04\x8a\x05\x02\n\n\r\n\x05\x04\x0e\x02\x02\x06\x12\
9291    \x04\x8a\x05\x0b\x1e\n\r\n\x05\x04\x0e\x02\x02\x01\x12\x04\x8a\x05\x1f3\
9292    \n\r\n\x05\x04\x0e\x02\x02\x03\x12\x04\x8a\x0569\nZ\n\x03\x04\x0e\x05\
9293    \x12\x04\x8d\x05\x02\x19\x1aM\x20Clients\x20can\x20define\x20custom\x20o\
9294    ptions\x20in\x20extensions\x20of\x20this\x20message.\x20See\x20above.\n\
9295    \n\x0c\n\x04\x04\x0e\x05\0\x12\x04\x8d\x05\r\x18\n\r\n\x05\x04\x0e\x05\0\
9296    \x01\x12\x04\x8d\x05\r\x11\n\r\n\x05\x04\x0e\x05\0\x02\x12\x04\x8d\x05\
9297    \x15\x18\n\x0c\n\x02\x04\x0f\x12\x06\x90\x05\0\x9c\x05\x01\n\x0b\n\x03\
9298    \x04\x0f\x01\x12\x04\x90\x05\x08\x18\n\xf7\x01\n\x04\x04\x0f\x02\0\x12\
9299    \x04\x95\x05\x021\x1a\xe8\x01\x20Is\x20this\x20enum\x20value\x20deprecat\
9300    ed?\n\x20Depending\x20on\x20the\x20target\x20platform,\x20this\x20can\
9301    \x20emit\x20Deprecated\x20annotations\n\x20for\x20the\x20enum\x20value,\
9302    \x20or\x20it\x20will\x20be\x20completely\x20ignored;\x20in\x20the\x20ver\
9303    y\x20least,\n\x20this\x20is\x20a\x20formalization\x20for\x20deprecating\
9304    \x20enum\x20values.\n\n\r\n\x05\x04\x0f\x02\0\x04\x12\x04\x95\x05\x02\n\
9305    \n\r\n\x05\x04\x0f\x02\0\x05\x12\x04\x95\x05\x0b\x0f\n\r\n\x05\x04\x0f\
9306    \x02\0\x01\x12\x04\x95\x05\x10\x1a\n\r\n\x05\x04\x0f\x02\0\x03\x12\x04\
9307    \x95\x05\x1d\x1e\n\r\n\x05\x04\x0f\x02\0\x08\x12\x04\x95\x05\x1f0\n\r\n\
9308    \x05\x04\x0f\x02\0\x07\x12\x04\x95\x05*/\nO\n\x04\x04\x0f\x02\x01\x12\
9309    \x04\x98\x05\x02:\x1aA\x20The\x20parser\x20stores\x20options\x20it\x20do\
9310    esn't\x20recognize\x20here.\x20See\x20above.\n\n\r\n\x05\x04\x0f\x02\x01\
9311    \x04\x12\x04\x98\x05\x02\n\n\r\n\x05\x04\x0f\x02\x01\x06\x12\x04\x98\x05\
9312    \x0b\x1e\n\r\n\x05\x04\x0f\x02\x01\x01\x12\x04\x98\x05\x1f3\n\r\n\x05\
9313    \x04\x0f\x02\x01\x03\x12\x04\x98\x0569\nZ\n\x03\x04\x0f\x05\x12\x04\x9b\
9314    \x05\x02\x19\x1aM\x20Clients\x20can\x20define\x20custom\x20options\x20in\
9315    \x20extensions\x20of\x20this\x20message.\x20See\x20above.\n\n\x0c\n\x04\
9316    \x04\x0f\x05\0\x12\x04\x9b\x05\r\x18\n\r\n\x05\x04\x0f\x05\0\x01\x12\x04\
9317    \x9b\x05\r\x11\n\r\n\x05\x04\x0f\x05\0\x02\x12\x04\x9b\x05\x15\x18\n\x0c\
9318    \n\x02\x04\x10\x12\x06\x9e\x05\0\xb0\x05\x01\n\x0b\n\x03\x04\x10\x01\x12\
9319    \x04\x9e\x05\x08\x16\n\xd9\x03\n\x04\x04\x10\x02\0\x12\x04\xa9\x05\x022\
9320    \x1a\xdf\x01\x20Is\x20this\x20service\x20deprecated?\n\x20Depending\x20o\
9321    n\x20the\x20target\x20platform,\x20this\x20can\x20emit\x20Deprecated\x20\
9322    annotations\n\x20for\x20the\x20service,\x20or\x20it\x20will\x20be\x20com\
9323    pletely\x20ignored;\x20in\x20the\x20very\x20least,\n\x20this\x20is\x20a\
9324    \x20formalization\x20for\x20deprecating\x20services.\n2\xe8\x01\x20Note:\
9325    \x20\x20Field\x20numbers\x201\x20through\x2032\x20are\x20reserved\x20for\
9326    \x20Google's\x20internal\x20RPC\n\x20\x20\x20framework.\x20\x20We\x20apo\
9327    logize\x20for\x20hoarding\x20these\x20numbers\x20to\x20ourselves,\x20but\
9328    \n\x20\x20\x20we\x20were\x20already\x20using\x20them\x20long\x20before\
9329    \x20we\x20decided\x20to\x20release\x20Protocol\n\x20\x20\x20Buffers.\n\n\
9330    \r\n\x05\x04\x10\x02\0\x04\x12\x04\xa9\x05\x02\n\n\r\n\x05\x04\x10\x02\0\
9331    \x05\x12\x04\xa9\x05\x0b\x0f\n\r\n\x05\x04\x10\x02\0\x01\x12\x04\xa9\x05\
9332    \x10\x1a\n\r\n\x05\x04\x10\x02\0\x03\x12\x04\xa9\x05\x1d\x1f\n\r\n\x05\
9333    \x04\x10\x02\0\x08\x12\x04\xa9\x05\x201\n\r\n\x05\x04\x10\x02\0\x07\x12\
9334    \x04\xa9\x05+0\nO\n\x04\x04\x10\x02\x01\x12\x04\xac\x05\x02:\x1aA\x20The\
9335    \x20parser\x20stores\x20options\x20it\x20doesn't\x20recognize\x20here.\
9336    \x20See\x20above.\n\n\r\n\x05\x04\x10\x02\x01\x04\x12\x04\xac\x05\x02\n\
9337    \n\r\n\x05\x04\x10\x02\x01\x06\x12\x04\xac\x05\x0b\x1e\n\r\n\x05\x04\x10\
9338    \x02\x01\x01\x12\x04\xac\x05\x1f3\n\r\n\x05\x04\x10\x02\x01\x03\x12\x04\
9339    \xac\x0569\nZ\n\x03\x04\x10\x05\x12\x04\xaf\x05\x02\x19\x1aM\x20Clients\
9340    \x20can\x20define\x20custom\x20options\x20in\x20extensions\x20of\x20this\
9341    \x20message.\x20See\x20above.\n\n\x0c\n\x04\x04\x10\x05\0\x12\x04\xaf\
9342    \x05\r\x18\n\r\n\x05\x04\x10\x05\0\x01\x12\x04\xaf\x05\r\x11\n\r\n\x05\
9343    \x04\x10\x05\0\x02\x12\x04\xaf\x05\x15\x18\n\x0c\n\x02\x04\x11\x12\x06\
9344    \xb2\x05\0\xcf\x05\x01\n\x0b\n\x03\x04\x11\x01\x12\x04\xb2\x05\x08\x15\n\
9345    \xd6\x03\n\x04\x04\x11\x02\0\x12\x04\xbd\x05\x022\x1a\xdc\x01\x20Is\x20t\
9346    his\x20method\x20deprecated?\n\x20Depending\x20on\x20the\x20target\x20pl\
9347    atform,\x20this\x20can\x20emit\x20Deprecated\x20annotations\n\x20for\x20\
9348    the\x20method,\x20or\x20it\x20will\x20be\x20completely\x20ignored;\x20in\
9349    \x20the\x20very\x20least,\n\x20this\x20is\x20a\x20formalization\x20for\
9350    \x20deprecating\x20methods.\n2\xe8\x01\x20Note:\x20\x20Field\x20numbers\
9351    \x201\x20through\x2032\x20are\x20reserved\x20for\x20Google's\x20internal\
9352    \x20RPC\n\x20\x20\x20framework.\x20\x20We\x20apologize\x20for\x20hoardin\
9353    g\x20these\x20numbers\x20to\x20ourselves,\x20but\n\x20\x20\x20we\x20were\
9354    \x20already\x20using\x20them\x20long\x20before\x20we\x20decided\x20to\
9355    \x20release\x20Protocol\n\x20\x20\x20Buffers.\n\n\r\n\x05\x04\x11\x02\0\
9356    \x04\x12\x04\xbd\x05\x02\n\n\r\n\x05\x04\x11\x02\0\x05\x12\x04\xbd\x05\
9357    \x0b\x0f\n\r\n\x05\x04\x11\x02\0\x01\x12\x04\xbd\x05\x10\x1a\n\r\n\x05\
9358    \x04\x11\x02\0\x03\x12\x04\xbd\x05\x1d\x1f\n\r\n\x05\x04\x11\x02\0\x08\
9359    \x12\x04\xbd\x05\x201\n\r\n\x05\x04\x11\x02\0\x07\x12\x04\xbd\x05+0\n\
9360    \xf0\x01\n\x04\x04\x11\x04\0\x12\x06\xc2\x05\x02\xc6\x05\x03\x1a\xdf\x01\
9361    \x20Is\x20this\x20method\x20side-effect-free\x20(or\x20safe\x20in\x20HTT\
9362    P\x20parlance),\x20or\x20idempotent,\n\x20or\x20neither?\x20HTTP\x20base\
9363    d\x20RPC\x20implementation\x20may\x20choose\x20GET\x20verb\x20for\x20saf\
9364    e\n\x20methods,\x20and\x20PUT\x20verb\x20for\x20idempotent\x20methods\
9365    \x20instead\x20of\x20the\x20default\x20POST.\n\n\r\n\x05\x04\x11\x04\0\
9366    \x01\x12\x04\xc2\x05\x07\x17\n\x0e\n\x06\x04\x11\x04\0\x02\0\x12\x04\xc3\
9367    \x05\x04\x1c\n\x0f\n\x07\x04\x11\x04\0\x02\0\x01\x12\x04\xc3\x05\x04\x17\
9368    \n\x0f\n\x07\x04\x11\x04\0\x02\0\x02\x12\x04\xc3\x05\x1a\x1b\n$\n\x06\
9369    \x04\x11\x04\0\x02\x01\x12\x04\xc4\x05\x04\x18\"\x14\x20implies\x20idemp\
9370    otent\n\n\x0f\n\x07\x04\x11\x04\0\x02\x01\x01\x12\x04\xc4\x05\x04\x13\n\
9371    \x0f\n\x07\x04\x11\x04\0\x02\x01\x02\x12\x04\xc4\x05\x16\x17\n7\n\x06\
9372    \x04\x11\x04\0\x02\x02\x12\x04\xc5\x05\x04\x13\"'\x20idempotent,\x20but\
9373    \x20may\x20have\x20side\x20effects\n\n\x0f\n\x07\x04\x11\x04\0\x02\x02\
9374    \x01\x12\x04\xc5\x05\x04\x0e\n\x0f\n\x07\x04\x11\x04\0\x02\x02\x02\x12\
9375    \x04\xc5\x05\x11\x12\n\x0e\n\x04\x04\x11\x02\x01\x12\x06\xc7\x05\x02\xc8\
9376    \x05&\n\r\n\x05\x04\x11\x02\x01\x04\x12\x04\xc7\x05\x02\n\n\r\n\x05\x04\
9377    \x11\x02\x01\x06\x12\x04\xc7\x05\x0b\x1b\n\r\n\x05\x04\x11\x02\x01\x01\
9378    \x12\x04\xc7\x05\x1c-\n\r\n\x05\x04\x11\x02\x01\x03\x12\x04\xc7\x0502\n\
9379    \r\n\x05\x04\x11\x02\x01\x08\x12\x04\xc8\x05\x06%\n\r\n\x05\x04\x11\x02\
9380    \x01\x07\x12\x04\xc8\x05\x11$\nO\n\x04\x04\x11\x02\x02\x12\x04\xcb\x05\
9381    \x02:\x1aA\x20The\x20parser\x20stores\x20options\x20it\x20doesn't\x20rec\
9382    ognize\x20here.\x20See\x20above.\n\n\r\n\x05\x04\x11\x02\x02\x04\x12\x04\
9383    \xcb\x05\x02\n\n\r\n\x05\x04\x11\x02\x02\x06\x12\x04\xcb\x05\x0b\x1e\n\r\
9384    \n\x05\x04\x11\x02\x02\x01\x12\x04\xcb\x05\x1f3\n\r\n\x05\x04\x11\x02\
9385    \x02\x03\x12\x04\xcb\x0569\nZ\n\x03\x04\x11\x05\x12\x04\xce\x05\x02\x19\
9386    \x1aM\x20Clients\x20can\x20define\x20custom\x20options\x20in\x20extensio\
9387    ns\x20of\x20this\x20message.\x20See\x20above.\n\n\x0c\n\x04\x04\x11\x05\
9388    \0\x12\x04\xce\x05\r\x18\n\r\n\x05\x04\x11\x05\0\x01\x12\x04\xce\x05\r\
9389    \x11\n\r\n\x05\x04\x11\x05\0\x02\x12\x04\xce\x05\x15\x18\n\x8b\x03\n\x02\
9390    \x04\x12\x12\x06\xd8\x05\0\xec\x05\x01\x1a\xfc\x02\x20A\x20message\x20re\
9391    presenting\x20a\x20option\x20the\x20parser\x20does\x20not\x20recognize.\
9392    \x20This\x20only\n\x20appears\x20in\x20options\x20protos\x20created\x20b\
9393    y\x20the\x20compiler::Parser\x20class.\n\x20DescriptorPool\x20resolves\
9394    \x20these\x20when\x20building\x20Descriptor\x20objects.\x20Therefore,\n\
9395    \x20options\x20protos\x20in\x20descriptor\x20objects\x20(e.g.\x20returne\
9396    d\x20by\x20Descriptor::options(),\n\x20or\x20produced\x20by\x20Descripto\
9397    r::CopyTo())\x20will\x20never\x20have\x20UninterpretedOptions\n\x20in\
9398    \x20them.\n\n\x0b\n\x03\x04\x12\x01\x12\x04\xd8\x05\x08\x1b\n\xcb\x02\n\
9399    \x04\x04\x12\x03\0\x12\x06\xde\x05\x02\xe1\x05\x03\x1a\xba\x02\x20The\
9400    \x20name\x20of\x20the\x20uninterpreted\x20option.\x20\x20Each\x20string\
9401    \x20represents\x20a\x20segment\x20in\n\x20a\x20dot-separated\x20name.\
9402    \x20\x20is_extension\x20is\x20true\x20iff\x20a\x20segment\x20represents\
9403    \x20an\n\x20extension\x20(denoted\x20with\x20parentheses\x20in\x20option\
9404    s\x20specs\x20in\x20.proto\x20files).\n\x20E.g.,{\x20[\"foo\",\x20false]\
9405    ,\x20[\"bar.baz\",\x20true],\x20[\"qux\",\x20false]\x20}\x20represents\n\
9406    \x20\"foo.(bar.baz).qux\".\n\n\r\n\x05\x04\x12\x03\0\x01\x12\x04\xde\x05\
9407    \n\x12\n\x0e\n\x06\x04\x12\x03\0\x02\0\x12\x04\xdf\x05\x04\"\n\x0f\n\x07\
9408    \x04\x12\x03\0\x02\0\x04\x12\x04\xdf\x05\x04\x0c\n\x0f\n\x07\x04\x12\x03\
9409    \0\x02\0\x05\x12\x04\xdf\x05\r\x13\n\x0f\n\x07\x04\x12\x03\0\x02\0\x01\
9410    \x12\x04\xdf\x05\x14\x1d\n\x0f\n\x07\x04\x12\x03\0\x02\0\x03\x12\x04\xdf\
9411    \x05\x20!\n\x0e\n\x06\x04\x12\x03\0\x02\x01\x12\x04\xe0\x05\x04#\n\x0f\n\
9412    \x07\x04\x12\x03\0\x02\x01\x04\x12\x04\xe0\x05\x04\x0c\n\x0f\n\x07\x04\
9413    \x12\x03\0\x02\x01\x05\x12\x04\xe0\x05\r\x11\n\x0f\n\x07\x04\x12\x03\0\
9414    \x02\x01\x01\x12\x04\xe0\x05\x12\x1e\n\x0f\n\x07\x04\x12\x03\0\x02\x01\
9415    \x03\x12\x04\xe0\x05!\"\n\x0c\n\x04\x04\x12\x02\0\x12\x04\xe2\x05\x02\
9416    \x1d\n\r\n\x05\x04\x12\x02\0\x04\x12\x04\xe2\x05\x02\n\n\r\n\x05\x04\x12\
9417    \x02\0\x06\x12\x04\xe2\x05\x0b\x13\n\r\n\x05\x04\x12\x02\0\x01\x12\x04\
9418    \xe2\x05\x14\x18\n\r\n\x05\x04\x12\x02\0\x03\x12\x04\xe2\x05\x1b\x1c\n\
9419    \x9c\x01\n\x04\x04\x12\x02\x01\x12\x04\xe6\x05\x02'\x1a\x8d\x01\x20The\
9420    \x20value\x20of\x20the\x20uninterpreted\x20option,\x20in\x20whatever\x20\
9421    type\x20the\x20tokenizer\n\x20identified\x20it\x20as\x20during\x20parsin\
9422    g.\x20Exactly\x20one\x20of\x20these\x20should\x20be\x20set.\n\n\r\n\x05\
9423    \x04\x12\x02\x01\x04\x12\x04\xe6\x05\x02\n\n\r\n\x05\x04\x12\x02\x01\x05\
9424    \x12\x04\xe6\x05\x0b\x11\n\r\n\x05\x04\x12\x02\x01\x01\x12\x04\xe6\x05\
9425    \x12\"\n\r\n\x05\x04\x12\x02\x01\x03\x12\x04\xe6\x05%&\n\x0c\n\x04\x04\
9426    \x12\x02\x02\x12\x04\xe7\x05\x02)\n\r\n\x05\x04\x12\x02\x02\x04\x12\x04\
9427    \xe7\x05\x02\n\n\r\n\x05\x04\x12\x02\x02\x05\x12\x04\xe7\x05\x0b\x11\n\r\
9428    \n\x05\x04\x12\x02\x02\x01\x12\x04\xe7\x05\x12$\n\r\n\x05\x04\x12\x02\
9429    \x02\x03\x12\x04\xe7\x05'(\n\x0c\n\x04\x04\x12\x02\x03\x12\x04\xe8\x05\
9430    \x02(\n\r\n\x05\x04\x12\x02\x03\x04\x12\x04\xe8\x05\x02\n\n\r\n\x05\x04\
9431    \x12\x02\x03\x05\x12\x04\xe8\x05\x0b\x10\n\r\n\x05\x04\x12\x02\x03\x01\
9432    \x12\x04\xe8\x05\x11#\n\r\n\x05\x04\x12\x02\x03\x03\x12\x04\xe8\x05&'\n\
9433    \x0c\n\x04\x04\x12\x02\x04\x12\x04\xe9\x05\x02#\n\r\n\x05\x04\x12\x02\
9434    \x04\x04\x12\x04\xe9\x05\x02\n\n\r\n\x05\x04\x12\x02\x04\x05\x12\x04\xe9\
9435    \x05\x0b\x11\n\r\n\x05\x04\x12\x02\x04\x01\x12\x04\xe9\x05\x12\x1e\n\r\n\
9436    \x05\x04\x12\x02\x04\x03\x12\x04\xe9\x05!\"\n\x0c\n\x04\x04\x12\x02\x05\
9437    \x12\x04\xea\x05\x02\"\n\r\n\x05\x04\x12\x02\x05\x04\x12\x04\xea\x05\x02\
9438    \n\n\r\n\x05\x04\x12\x02\x05\x05\x12\x04\xea\x05\x0b\x10\n\r\n\x05\x04\
9439    \x12\x02\x05\x01\x12\x04\xea\x05\x11\x1d\n\r\n\x05\x04\x12\x02\x05\x03\
9440    \x12\x04\xea\x05\x20!\n\x0c\n\x04\x04\x12\x02\x06\x12\x04\xeb\x05\x02&\n\
9441    \r\n\x05\x04\x12\x02\x06\x04\x12\x04\xeb\x05\x02\n\n\r\n\x05\x04\x12\x02\
9442    \x06\x05\x12\x04\xeb\x05\x0b\x11\n\r\n\x05\x04\x12\x02\x06\x01\x12\x04\
9443    \xeb\x05\x12!\n\r\n\x05\x04\x12\x02\x06\x03\x12\x04\xeb\x05$%\n\xda\x01\
9444    \n\x02\x04\x13\x12\x06\xf3\x05\0\xf4\x06\x01\x1aj\x20Encapsulates\x20inf\
9445    ormation\x20about\x20the\x20original\x20source\x20file\x20from\x20which\
9446    \x20a\n\x20FileDescriptorProto\x20was\x20generated.\n2`\x20=============\
9447    ======================================================\n\x20Optional\x20\
9448    source\x20code\x20info\n\n\x0b\n\x03\x04\x13\x01\x12\x04\xf3\x05\x08\x16\
9449    \n\x82\x11\n\x04\x04\x13\x02\0\x12\x04\x9f\x06\x02!\x1a\xf3\x10\x20A\x20\
9450    Location\x20identifies\x20a\x20piece\x20of\x20source\x20code\x20in\x20a\
9451    \x20.proto\x20file\x20which\n\x20corresponds\x20to\x20a\x20particular\
9452    \x20definition.\x20\x20This\x20information\x20is\x20intended\n\x20to\x20\
9453    be\x20useful\x20to\x20IDEs,\x20code\x20indexers,\x20documentation\x20gen\
9454    erators,\x20and\x20similar\n\x20tools.\n\n\x20For\x20example,\x20say\x20\
9455    we\x20have\x20a\x20file\x20like:\n\x20\x20\x20message\x20Foo\x20{\n\x20\
9456    \x20\x20\x20\x20optional\x20string\x20foo\x20=\x201;\n\x20\x20\x20}\n\
9457    \x20Let's\x20look\x20at\x20just\x20the\x20field\x20definition:\n\x20\x20\
9458    \x20optional\x20string\x20foo\x20=\x201;\n\x20\x20\x20^\x20\x20\x20\x20\
9459    \x20\x20\x20^^\x20\x20\x20\x20\x20^^\x20\x20^\x20\x20^^^\n\x20\x20\x20a\
9460    \x20\x20\x20\x20\x20\x20\x20bc\x20\x20\x20\x20\x20de\x20\x20f\x20\x20ghi\
9461    \n\x20We\x20have\x20the\x20following\x20locations:\n\x20\x20\x20span\x20\
9462    \x20\x20path\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\
9463    represents\n\x20\x20\x20[a,i)\x20\x20[\x204,\x200,\x202,\x200\x20]\x20\
9464    \x20\x20\x20\x20The\x20whole\x20field\x20definition.\n\x20\x20\x20[a,b)\
9465    \x20\x20[\x204,\x200,\x202,\x200,\x204\x20]\x20\x20The\x20label\x20(opti\
9466    onal).\n\x20\x20\x20[c,d)\x20\x20[\x204,\x200,\x202,\x200,\x205\x20]\x20\
9467    \x20The\x20type\x20(string).\n\x20\x20\x20[e,f)\x20\x20[\x204,\x200,\x20\
9468    2,\x200,\x201\x20]\x20\x20The\x20name\x20(foo).\n\x20\x20\x20[g,h)\x20\
9469    \x20[\x204,\x200,\x202,\x200,\x203\x20]\x20\x20The\x20number\x20(1).\n\n\
9470    \x20Notes:\n\x20-\x20A\x20location\x20may\x20refer\x20to\x20a\x20repeate\
9471    d\x20field\x20itself\x20(i.e.\x20not\x20to\x20any\n\x20\x20\x20particula\
9472    r\x20index\x20within\x20it).\x20\x20This\x20is\x20used\x20whenever\x20a\
9473    \x20set\x20of\x20elements\x20are\n\x20\x20\x20logically\x20enclosed\x20i\
9474    n\x20a\x20single\x20code\x20segment.\x20\x20For\x20example,\x20an\x20ent\
9475    ire\n\x20\x20\x20extend\x20block\x20(possibly\x20containing\x20multiple\
9476    \x20extension\x20definitions)\x20will\n\x20\x20\x20have\x20an\x20outer\
9477    \x20location\x20whose\x20path\x20refers\x20to\x20the\x20\"extensions\"\
9478    \x20repeated\n\x20\x20\x20field\x20without\x20an\x20index.\n\x20-\x20Mul\
9479    tiple\x20locations\x20may\x20have\x20the\x20same\x20path.\x20\x20This\
9480    \x20happens\x20when\x20a\x20single\n\x20\x20\x20logical\x20declaration\
9481    \x20is\x20spread\x20out\x20across\x20multiple\x20places.\x20\x20The\x20m\
9482    ost\n\x20\x20\x20obvious\x20example\x20is\x20the\x20\"extend\"\x20block\
9483    \x20again\x20--\x20there\x20may\x20be\x20multiple\n\x20\x20\x20extend\
9484    \x20blocks\x20in\x20the\x20same\x20scope,\x20each\x20of\x20which\x20will\
9485    \x20have\x20the\x20same\x20path.\n\x20-\x20A\x20location's\x20span\x20is\
9486    \x20not\x20always\x20a\x20subset\x20of\x20its\x20parent's\x20span.\x20\
9487    \x20For\n\x20\x20\x20example,\x20the\x20\"extendee\"\x20of\x20an\x20exte\
9488    nsion\x20declaration\x20appears\x20at\x20the\n\x20\x20\x20beginning\x20o\
9489    f\x20the\x20\"extend\"\x20block\x20and\x20is\x20shared\x20by\x20all\x20e\
9490    xtensions\x20within\n\x20\x20\x20the\x20block.\n\x20-\x20Just\x20because\
9491    \x20a\x20location's\x20span\x20is\x20a\x20subset\x20of\x20some\x20other\
9492    \x20location's\x20span\n\x20\x20\x20does\x20not\x20mean\x20that\x20it\
9493    \x20is\x20a\x20descendant.\x20\x20For\x20example,\x20a\x20\"group\"\x20d\
9494    efines\n\x20\x20\x20both\x20a\x20type\x20and\x20a\x20field\x20in\x20a\
9495    \x20single\x20declaration.\x20\x20Thus,\x20the\x20locations\n\x20\x20\
9496    \x20corresponding\x20to\x20the\x20type\x20and\x20field\x20and\x20their\
9497    \x20components\x20will\x20overlap.\n\x20-\x20Code\x20which\x20tries\x20t\
9498    o\x20interpret\x20locations\x20should\x20probably\x20be\x20designed\x20t\
9499    o\n\x20\x20\x20ignore\x20those\x20that\x20it\x20doesn't\x20understand,\
9500    \x20as\x20more\x20types\x20of\x20locations\x20could\n\x20\x20\x20be\x20r\
9501    ecorded\x20in\x20the\x20future.\n\n\r\n\x05\x04\x13\x02\0\x04\x12\x04\
9502    \x9f\x06\x02\n\n\r\n\x05\x04\x13\x02\0\x06\x12\x04\x9f\x06\x0b\x13\n\r\n\
9503    \x05\x04\x13\x02\0\x01\x12\x04\x9f\x06\x14\x1c\n\r\n\x05\x04\x13\x02\0\
9504    \x03\x12\x04\x9f\x06\x1f\x20\n\x0e\n\x04\x04\x13\x03\0\x12\x06\xa0\x06\
9505    \x02\xf3\x06\x03\n\r\n\x05\x04\x13\x03\0\x01\x12\x04\xa0\x06\n\x12\n\x83\
9506    \x07\n\x06\x04\x13\x03\0\x02\0\x12\x04\xb8\x06\x04,\x1a\xf2\x06\x20Ident\
9507    ifies\x20which\x20part\x20of\x20the\x20FileDescriptorProto\x20was\x20def\
9508    ined\x20at\x20this\n\x20location.\n\n\x20Each\x20element\x20is\x20a\x20f\
9509    ield\x20number\x20or\x20an\x20index.\x20\x20They\x20form\x20a\x20path\
9510    \x20from\n\x20the\x20root\x20FileDescriptorProto\x20to\x20the\x20place\
9511    \x20where\x20the\x20definition.\x20\x20For\n\x20example,\x20this\x20path\
9512    :\n\x20\x20\x20[\x204,\x203,\x202,\x207,\x201\x20]\n\x20refers\x20to:\n\
9513    \x20\x20\x20file.message_type(3)\x20\x20//\x204,\x203\n\x20\x20\x20\x20\
9514    \x20\x20\x20.field(7)\x20\x20\x20\x20\x20\x20\x20\x20\x20//\x202,\x207\n\
9515    \x20\x20\x20\x20\x20\x20\x20.name()\x20\x20\x20\x20\x20\x20\x20\x20\x20\
9516    \x20\x20//\x201\n\x20This\x20is\x20because\x20FileDescriptorProto.messag\
9517    e_type\x20has\x20field\x20number\x204:\n\x20\x20\x20repeated\x20Descript\
9518    orProto\x20message_type\x20=\x204;\n\x20and\x20DescriptorProto.field\x20\
9519    has\x20field\x20number\x202:\n\x20\x20\x20repeated\x20FieldDescriptorPro\
9520    to\x20field\x20=\x202;\n\x20and\x20FieldDescriptorProto.name\x20has\x20f\
9521    ield\x20number\x201:\n\x20\x20\x20optional\x20string\x20name\x20=\x201;\
9522    \n\n\x20Thus,\x20the\x20above\x20path\x20gives\x20the\x20location\x20of\
9523    \x20a\x20field\x20name.\x20\x20If\x20we\x20removed\n\x20the\x20last\x20e\
9524    lement:\n\x20\x20\x20[\x204,\x203,\x202,\x207\x20]\n\x20this\x20path\x20\
9525    refers\x20to\x20the\x20whole\x20field\x20declaration\x20(from\x20the\x20\
9526    beginning\n\x20of\x20the\x20label\x20to\x20the\x20terminating\x20semicol\
9527    on).\n\n\x0f\n\x07\x04\x13\x03\0\x02\0\x04\x12\x04\xb8\x06\x04\x0c\n\x0f\
9528    \n\x07\x04\x13\x03\0\x02\0\x05\x12\x04\xb8\x06\r\x12\n\x0f\n\x07\x04\x13\
9529    \x03\0\x02\0\x01\x12\x04\xb8\x06\x13\x17\n\x0f\n\x07\x04\x13\x03\0\x02\0\
9530    \x03\x12\x04\xb8\x06\x1a\x1b\n\x0f\n\x07\x04\x13\x03\0\x02\0\x08\x12\x04\
9531    \xb8\x06\x1c+\n\x10\n\x08\x04\x13\x03\0\x02\0\x08\x02\x12\x04\xb8\x06\
9532    \x1d*\n\xd2\x02\n\x06\x04\x13\x03\0\x02\x01\x12\x04\xbf\x06\x04,\x1a\xc1\
9533    \x02\x20Always\x20has\x20exactly\x20three\x20or\x20four\x20elements:\x20\
9534    start\x20line,\x20start\x20column,\n\x20end\x20line\x20(optional,\x20oth\
9535    erwise\x20assumed\x20same\x20as\x20start\x20line),\x20end\x20column.\n\
9536    \x20These\x20are\x20packed\x20into\x20a\x20single\x20field\x20for\x20eff\
9537    iciency.\x20\x20Note\x20that\x20line\n\x20and\x20column\x20numbers\x20ar\
9538    e\x20zero-based\x20--\x20typically\x20you\x20will\x20want\x20to\x20add\n\
9539    \x201\x20to\x20each\x20before\x20displaying\x20to\x20a\x20user.\n\n\x0f\
9540    \n\x07\x04\x13\x03\0\x02\x01\x04\x12\x04\xbf\x06\x04\x0c\n\x0f\n\x07\x04\
9541    \x13\x03\0\x02\x01\x05\x12\x04\xbf\x06\r\x12\n\x0f\n\x07\x04\x13\x03\0\
9542    \x02\x01\x01\x12\x04\xbf\x06\x13\x17\n\x0f\n\x07\x04\x13\x03\0\x02\x01\
9543    \x03\x12\x04\xbf\x06\x1a\x1b\n\x0f\n\x07\x04\x13\x03\0\x02\x01\x08\x12\
9544    \x04\xbf\x06\x1c+\n\x10\n\x08\x04\x13\x03\0\x02\x01\x08\x02\x12\x04\xbf\
9545    \x06\x1d*\n\xa5\x0c\n\x06\x04\x13\x03\0\x02\x02\x12\x04\xf0\x06\x04)\x1a\
9546    \x94\x0c\x20If\x20this\x20SourceCodeInfo\x20represents\x20a\x20complete\
9547    \x20declaration,\x20these\x20are\x20any\n\x20comments\x20appearing\x20be\
9548    fore\x20and\x20after\x20the\x20declaration\x20which\x20appear\x20to\x20b\
9549    e\n\x20attached\x20to\x20the\x20declaration.\n\n\x20A\x20series\x20of\
9550    \x20line\x20comments\x20appearing\x20on\x20consecutive\x20lines,\x20with\
9551    \x20no\x20other\n\x20tokens\x20appearing\x20on\x20those\x20lines,\x20wil\
9552    l\x20be\x20treated\x20as\x20a\x20single\x20comment.\n\n\x20leading_detac\
9553    hed_comments\x20will\x20keep\x20paragraphs\x20of\x20comments\x20that\x20\
9554    appear\n\x20before\x20(but\x20not\x20connected\x20to)\x20the\x20current\
9555    \x20element.\x20Each\x20paragraph,\n\x20separated\x20by\x20empty\x20line\
9556    s,\x20will\x20be\x20one\x20comment\x20element\x20in\x20the\x20repeated\n\
9557    \x20field.\n\n\x20Only\x20the\x20comment\x20content\x20is\x20provided;\
9558    \x20comment\x20markers\x20(e.g.\x20//)\x20are\n\x20stripped\x20out.\x20\
9559    \x20For\x20block\x20comments,\x20leading\x20whitespace\x20and\x20an\x20a\
9560    sterisk\n\x20will\x20be\x20stripped\x20from\x20the\x20beginning\x20of\
9561    \x20each\x20line\x20other\x20than\x20the\x20first.\n\x20Newlines\x20are\
9562    \x20included\x20in\x20the\x20output.\n\n\x20Examples:\n\n\x20\x20\x20opt\
9563    ional\x20int32\x20foo\x20=\x201;\x20\x20//\x20Comment\x20attached\x20to\
9564    \x20foo.\n\x20\x20\x20//\x20Comment\x20attached\x20to\x20bar.\n\x20\x20\
9565    \x20optional\x20int32\x20bar\x20=\x202;\n\n\x20\x20\x20optional\x20strin\
9566    g\x20baz\x20=\x203;\n\x20\x20\x20//\x20Comment\x20attached\x20to\x20baz.\
9567    \n\x20\x20\x20//\x20Another\x20line\x20attached\x20to\x20baz.\n\n\x20\
9568    \x20\x20//\x20Comment\x20attached\x20to\x20qux.\n\x20\x20\x20//\n\x20\
9569    \x20\x20//\x20Another\x20line\x20attached\x20to\x20qux.\n\x20\x20\x20opt\
9570    ional\x20double\x20qux\x20=\x204;\n\n\x20\x20\x20//\x20Detached\x20comme\
9571    nt\x20for\x20corge.\x20This\x20is\x20not\x20leading\x20or\x20trailing\
9572    \x20comments\n\x20\x20\x20//\x20to\x20qux\x20or\x20corge\x20because\x20t\
9573    here\x20are\x20blank\x20lines\x20separating\x20it\x20from\n\x20\x20\x20/\
9574    /\x20both.\n\n\x20\x20\x20//\x20Detached\x20comment\x20for\x20corge\x20p\
9575    aragraph\x202.\n\n\x20\x20\x20optional\x20string\x20corge\x20=\x205;\n\
9576    \x20\x20\x20/*\x20Block\x20comment\x20attached\n\x20\x20\x20\x20*\x20to\
9577    \x20corge.\x20\x20Leading\x20asterisks\n\x20\x20\x20\x20*\x20will\x20be\
9578    \x20removed.\x20*/\n\x20\x20\x20/*\x20Block\x20comment\x20attached\x20to\
9579    \n\x20\x20\x20\x20*\x20grault.\x20*/\n\x20\x20\x20optional\x20int32\x20g\
9580    rault\x20=\x206;\n\n\x20\x20\x20//\x20ignored\x20detached\x20comments.\n\
9581    \n\x0f\n\x07\x04\x13\x03\0\x02\x02\x04\x12\x04\xf0\x06\x04\x0c\n\x0f\n\
9582    \x07\x04\x13\x03\0\x02\x02\x05\x12\x04\xf0\x06\r\x13\n\x0f\n\x07\x04\x13\
9583    \x03\0\x02\x02\x01\x12\x04\xf0\x06\x14$\n\x0f\n\x07\x04\x13\x03\0\x02\
9584    \x02\x03\x12\x04\xf0\x06'(\n\x0e\n\x06\x04\x13\x03\0\x02\x03\x12\x04\xf1\
9585    \x06\x04*\n\x0f\n\x07\x04\x13\x03\0\x02\x03\x04\x12\x04\xf1\x06\x04\x0c\
9586    \n\x0f\n\x07\x04\x13\x03\0\x02\x03\x05\x12\x04\xf1\x06\r\x13\n\x0f\n\x07\
9587    \x04\x13\x03\0\x02\x03\x01\x12\x04\xf1\x06\x14%\n\x0f\n\x07\x04\x13\x03\
9588    \0\x02\x03\x03\x12\x04\xf1\x06()\n\x0e\n\x06\x04\x13\x03\0\x02\x04\x12\
9589    \x04\xf2\x06\x042\n\x0f\n\x07\x04\x13\x03\0\x02\x04\x04\x12\x04\xf2\x06\
9590    \x04\x0c\n\x0f\n\x07\x04\x13\x03\0\x02\x04\x05\x12\x04\xf2\x06\r\x13\n\
9591    \x0f\n\x07\x04\x13\x03\0\x02\x04\x01\x12\x04\xf2\x06\x14-\n\x0f\n\x07\
9592    \x04\x13\x03\0\x02\x04\x03\x12\x04\xf2\x0601\n\xee\x01\n\x02\x04\x14\x12\
9593    \x06\xf9\x06\0\x8e\x07\x01\x1a\xdf\x01\x20Describes\x20the\x20relationsh\
9594    ip\x20between\x20generated\x20code\x20and\x20its\x20original\x20source\n\
9595    \x20file.\x20A\x20GeneratedCodeInfo\x20message\x20is\x20associated\x20wi\
9596    th\x20only\x20one\x20generated\n\x20source\x20file,\x20but\x20may\x20con\
9597    tain\x20references\x20to\x20different\x20source\x20.proto\x20files.\n\n\
9598    \x0b\n\x03\x04\x14\x01\x12\x04\xf9\x06\x08\x19\nx\n\x04\x04\x14\x02\0\
9599    \x12\x04\xfc\x06\x02%\x1aj\x20An\x20Annotation\x20connects\x20some\x20sp\
9600    an\x20of\x20text\x20in\x20generated\x20code\x20to\x20an\x20element\n\x20\
9601    of\x20its\x20generating\x20.proto\x20file.\n\n\r\n\x05\x04\x14\x02\0\x04\
9602    \x12\x04\xfc\x06\x02\n\n\r\n\x05\x04\x14\x02\0\x06\x12\x04\xfc\x06\x0b\
9603    \x15\n\r\n\x05\x04\x14\x02\0\x01\x12\x04\xfc\x06\x16\x20\n\r\n\x05\x04\
9604    \x14\x02\0\x03\x12\x04\xfc\x06#$\n\x0e\n\x04\x04\x14\x03\0\x12\x06\xfd\
9605    \x06\x02\x8d\x07\x03\n\r\n\x05\x04\x14\x03\0\x01\x12\x04\xfd\x06\n\x14\n\
9606    \x8f\x01\n\x06\x04\x14\x03\0\x02\0\x12\x04\x80\x07\x04,\x1a\x7f\x20Ident\
9607    ifies\x20the\x20element\x20in\x20the\x20original\x20source\x20.proto\x20\
9608    file.\x20This\x20field\n\x20is\x20formatted\x20the\x20same\x20as\x20Sour\
9609    ceCodeInfo.Location.path.\n\n\x0f\n\x07\x04\x14\x03\0\x02\0\x04\x12\x04\
9610    \x80\x07\x04\x0c\n\x0f\n\x07\x04\x14\x03\0\x02\0\x05\x12\x04\x80\x07\r\
9611    \x12\n\x0f\n\x07\x04\x14\x03\0\x02\0\x01\x12\x04\x80\x07\x13\x17\n\x0f\n\
9612    \x07\x04\x14\x03\0\x02\0\x03\x12\x04\x80\x07\x1a\x1b\n\x0f\n\x07\x04\x14\
9613    \x03\0\x02\0\x08\x12\x04\x80\x07\x1c+\n\x10\n\x08\x04\x14\x03\0\x02\0\
9614    \x08\x02\x12\x04\x80\x07\x1d*\nO\n\x06\x04\x14\x03\0\x02\x01\x12\x04\x83\
9615    \x07\x04$\x1a?\x20Identifies\x20the\x20filesystem\x20path\x20to\x20the\
9616    \x20original\x20source\x20.proto.\n\n\x0f\n\x07\x04\x14\x03\0\x02\x01\
9617    \x04\x12\x04\x83\x07\x04\x0c\n\x0f\n\x07\x04\x14\x03\0\x02\x01\x05\x12\
9618    \x04\x83\x07\r\x13\n\x0f\n\x07\x04\x14\x03\0\x02\x01\x01\x12\x04\x83\x07\
9619    \x14\x1f\n\x0f\n\x07\x04\x14\x03\0\x02\x01\x03\x12\x04\x83\x07\"#\nw\n\
9620    \x06\x04\x14\x03\0\x02\x02\x12\x04\x87\x07\x04\x1d\x1ag\x20Identifies\
9621    \x20the\x20starting\x20offset\x20in\x20bytes\x20in\x20the\x20generated\
9622    \x20code\n\x20that\x20relates\x20to\x20the\x20identified\x20object.\n\n\
9623    \x0f\n\x07\x04\x14\x03\0\x02\x02\x04\x12\x04\x87\x07\x04\x0c\n\x0f\n\x07\
9624    \x04\x14\x03\0\x02\x02\x05\x12\x04\x87\x07\r\x12\n\x0f\n\x07\x04\x14\x03\
9625    \0\x02\x02\x01\x12\x04\x87\x07\x13\x18\n\x0f\n\x07\x04\x14\x03\0\x02\x02\
9626    \x03\x12\x04\x87\x07\x1b\x1c\n\xdb\x01\n\x06\x04\x14\x03\0\x02\x03\x12\
9627    \x04\x8c\x07\x04\x1b\x1a\xca\x01\x20Identifies\x20the\x20ending\x20offse\
9628    t\x20in\x20bytes\x20in\x20the\x20generated\x20code\x20that\n\x20relates\
9629    \x20to\x20the\x20identified\x20offset.\x20The\x20end\x20offset\x20should\
9630    \x20be\x20one\x20past\n\x20the\x20last\x20relevant\x20byte\x20(so\x20the\
9631    \x20length\x20of\x20the\x20text\x20=\x20end\x20-\x20begin).\n\n\x0f\n\
9632    \x07\x04\x14\x03\0\x02\x03\x04\x12\x04\x8c\x07\x04\x0c\n\x0f\n\x07\x04\
9633    \x14\x03\0\x02\x03\x05\x12\x04\x8c\x07\r\x12\n\x0f\n\x07\x04\x14\x03\0\
9634    \x02\x03\x01\x12\x04\x8c\x07\x13\x16\n\x0f\n\x07\x04\x14\x03\0\x02\x03\
9635    \x03\x12\x04\x8c\x07\x19\x1a\
9636";
9637
9638/// `FileDescriptorProto` object which was a source for this generated file
9639fn file_descriptor_proto() -> &'static crate::descriptor::FileDescriptorProto {
9640    static file_descriptor_proto_lazy: crate::rt::Lazy<crate::descriptor::FileDescriptorProto> = crate::rt::Lazy::new();
9641    file_descriptor_proto_lazy.get(|| {
9642        crate::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
9643    })
9644}
9645
9646/// `FileDescriptor` object which allows dynamic access to files
9647pub fn file_descriptor() -> &'static crate::reflect::FileDescriptor {
9648    static generated_file_descriptor_lazy: crate::rt::Lazy<crate::reflect::GeneratedFileDescriptor> = crate::rt::Lazy::new();
9649    static file_descriptor: crate::rt::Lazy<crate::reflect::FileDescriptor> = crate::rt::Lazy::new();
9650    file_descriptor.get(|| {
9651        let generated_file_descriptor = generated_file_descriptor_lazy.get(|| {
9652            let mut deps = ::std::vec::Vec::with_capacity(0);
9653            let mut messages = ::std::vec::Vec::with_capacity(27);
9654            messages.push(FileDescriptorSet::generated_message_descriptor_data());
9655            messages.push(FileDescriptorProto::generated_message_descriptor_data());
9656            messages.push(DescriptorProto::generated_message_descriptor_data());
9657            messages.push(ExtensionRangeOptions::generated_message_descriptor_data());
9658            messages.push(FieldDescriptorProto::generated_message_descriptor_data());
9659            messages.push(OneofDescriptorProto::generated_message_descriptor_data());
9660            messages.push(EnumDescriptorProto::generated_message_descriptor_data());
9661            messages.push(EnumValueDescriptorProto::generated_message_descriptor_data());
9662            messages.push(ServiceDescriptorProto::generated_message_descriptor_data());
9663            messages.push(MethodDescriptorProto::generated_message_descriptor_data());
9664            messages.push(FileOptions::generated_message_descriptor_data());
9665            messages.push(MessageOptions::generated_message_descriptor_data());
9666            messages.push(FieldOptions::generated_message_descriptor_data());
9667            messages.push(OneofOptions::generated_message_descriptor_data());
9668            messages.push(EnumOptions::generated_message_descriptor_data());
9669            messages.push(EnumValueOptions::generated_message_descriptor_data());
9670            messages.push(ServiceOptions::generated_message_descriptor_data());
9671            messages.push(MethodOptions::generated_message_descriptor_data());
9672            messages.push(UninterpretedOption::generated_message_descriptor_data());
9673            messages.push(SourceCodeInfo::generated_message_descriptor_data());
9674            messages.push(GeneratedCodeInfo::generated_message_descriptor_data());
9675            messages.push(descriptor_proto::ExtensionRange::generated_message_descriptor_data());
9676            messages.push(descriptor_proto::ReservedRange::generated_message_descriptor_data());
9677            messages.push(enum_descriptor_proto::EnumReservedRange::generated_message_descriptor_data());
9678            messages.push(uninterpreted_option::NamePart::generated_message_descriptor_data());
9679            messages.push(source_code_info::Location::generated_message_descriptor_data());
9680            messages.push(generated_code_info::Annotation::generated_message_descriptor_data());
9681            let mut enums = ::std::vec::Vec::with_capacity(6);
9682            enums.push(field_descriptor_proto::Type::generated_enum_descriptor_data());
9683            enums.push(field_descriptor_proto::Label::generated_enum_descriptor_data());
9684            enums.push(file_options::OptimizeMode::generated_enum_descriptor_data());
9685            enums.push(field_options::CType::generated_enum_descriptor_data());
9686            enums.push(field_options::JSType::generated_enum_descriptor_data());
9687            enums.push(method_options::IdempotencyLevel::generated_enum_descriptor_data());
9688            crate::reflect::GeneratedFileDescriptor::new_generated(
9689                file_descriptor_proto(),
9690                deps,
9691                messages,
9692                enums,
9693            )
9694        });
9695        crate::reflect::FileDescriptor::new_generated_2(generated_file_descriptor)
9696    })
9697}
protobuf/descriptor.rs

protobuf/
descriptor.rs
