
module ietf-descriptor {


    namespace "urn:opencord:params:xml:ns:voltha:ietf-descriptor";
    prefix descriptor;


    organization "CORD";
    contact
        " Any name";

    description
        "";

    revision "2016-11-15" {
        description "Initial revision.";
        reference "reference";
    }


    container FileDescriptorSet {
        description
            "The protocol compiler can output a FileDescriptorSet containing the .proto
 files it parses.";
        list file {
            key "name";
            uses  FileDescriptorProto;

            description
                "";
        }

    }

    grouping FileDescriptorProto {
        description
            "Describes a complete .proto file.";
        leaf name {
            type  string; 
            description
                "file name, relative to root of source tree";
        }

        leaf package {
            type  string; 
            description
                "e.g.  foo ,  foo.bar , etc.";
        }

        list dependency {
            key "dependency";
            leaf dependency {
                type  string; 
                description
                    "Names of files imported by this file.";
            }
            description
                "Names of files imported by this file.";
        }

        list public_dependency {
            key "public_dependency";
            leaf public_dependency {
                type  int32; 
                description
                    "Indexes of the public imported files in the dependency list above.";
            }
            description
                "Indexes of the public imported files in the dependency list above.";
        }

        list weak_dependency {
            key "weak_dependency";
            leaf weak_dependency {
                type  int32; 
                description
                    "Indexes of the weak imported files in the dependency list.
 For Google-internal migration only. Do not use.";
            }
            description
                "Indexes of the weak imported files in the dependency list.
 For Google-internal migration only. Do not use.";
        }

        list message_type {
            key "name";
            uses  DescriptorProto;

            description
                "All top-level definitions in this file.";
        }

        list enum_type {
            key "name";
            uses  EnumDescriptorProto;

            description
                "";
        }

        list service {
            key "name";
            uses  ServiceDescriptorProto;

            description
                "";
        }

        list extension {
            key "name";
            uses  FieldDescriptorProto;

            description
                "";
        }

        container options {
            uses  FileOptions;

            description
                "";
        }

        container source_code_info {
            uses  SourceCodeInfo;

            description
                "This field contains optional information about the original source code.
 You may safely remove this entire field without harming runtime
 functionality of the descriptors -- the information is needed only by
 development tools.";
        }

        leaf syntax {
            type  string; 
            description
                "The syntax of the proto file.
 The supported values are  proto2  and  proto3 .";
        }

    }

    grouping DescriptorProto {
        description
            "Describes a message type.";
        leaf name {
            type  string; 
            description
                "";
        }

        list field {
            key "name";
            uses  FieldDescriptorProto;

            description
                "";
        }

        list extension {
            key "name";
            uses  FieldDescriptorProto;

            description
                "";
        }

        list nested_type {
            key "name";
            uses  DescriptorProto;

            description
                "";
        }

        list enum_type {
            key "name";
            uses  EnumDescriptorProto;

            description
                "";
        }


        list oneof_decl {
            key "name";
            uses  OneofDescriptorProto;

            description
                "";
        }

        container options {
            uses  MessageOptions;

            description
                "";
        }


        list reserved_name {
            key "reserved_name";
            leaf reserved_name {
                type  string; 
                description
                    "Reserved field names, which may not be used by fields in the same message.
 A given name may only be reserved once.";
            }
            description
                "Reserved field names, which may not be used by fields in the same message.
 A given name may only be reserved once.";
        }

        grouping ExtensionRange {
            description
                "";
            leaf start {
                type  int32; 
                description
                    "";
            }
    
            leaf end {
                type  int32; 
                description
                    "";
            }
    
        }
    
        grouping ReservedRange {
            description
                "Range of reserved tag numbers. Reserved tag numbers may not be used by
     fields or extension ranges in the same message. Reserved ranges may
     not overlap.";
            leaf start {
                type  int32; 
                description
                    "Inclusive.";
            }
    
            leaf end {
                type  int32; 
                description
                    "Exclusive.";
            }
    
        }
    
    }

    grouping FieldDescriptorProto {
        description
            "Describes a field within a message.";
        leaf name {
            type  string; 
            description
                "";
        }

        leaf number {
            type  int32; 
            description
                "";
        }

        leaf label {
            type  Label; 
            description
                "";
        }

        leaf type {
            type  Type; 
            description
                "If type_name is set, this need not be set.  If both this and type_name
 are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP.";
        }

        leaf type_name {
            type  string; 
            description
                "For message and enum types, this is the name of the type.  If the name
 starts with a '.', it is fully-qualified.  Otherwise, C++-like scoping
 rules are used to find the type (i.e. first the nested types within this
 message are searched, then within the parent, on up to the root
 namespace).";
        }

        leaf extendee {
            type  string; 
            description
                "For extensions, this is the name of the type being extended.  It is
 resolved in the same manner as type_name.";
        }

        leaf default_value {
            type  string; 
            description
                "For numeric types, contains the original text representation of the value.
 For booleans,  true  or  false .
 For strings, contains the default text contents (not escaped in any way).
 For bytes, contains the C escaped value.  All bytes >= 128 are escaped.
 TODO(kenton):  Base-64 encode?";
        }

        leaf oneof_index {
            type  int32; 
            description
                "If set, gives the index of a oneof in the containing type's oneof_decl
 list.  This field is a member of that oneof.";
        }

        leaf json_name {
            type  string; 
            description
                "JSON name of this field. The value is set by protocol compiler. If the
 user has set a  json_name  option on this field, that option's value
 will be used. Otherwise, it's deduced from the field's name by converting
 it to camelCase.";
        }

        container options {
            uses  FieldOptions;

            description
                "";
        }

        typedef Type {
            type enumeration {
                enum TYPE_DOUBLE {
                    description "";
                }
                enum TYPE_FLOAT {
                    description "";
                }
                enum TYPE_INT64 {
                    description "";
                }
                enum TYPE_UINT64 {
                    description "";
                }
                enum TYPE_INT32 {
                    description "";
                }
                enum TYPE_FIXED64 {
                    description "";
                }
                enum TYPE_FIXED32 {
                    description "";
                }
                enum TYPE_BOOL {
                    description "";
                }
                enum TYPE_STRING {
                    description "";
                }
                enum TYPE_GROUP {
                    description "";
                }
                enum TYPE_MESSAGE {
                    description "";
                }
                enum TYPE_BYTES {
                    description "";
                }
                enum TYPE_UINT32 {
                    description "";
                }
                enum TYPE_ENUM {
                    description "";
                }
                enum TYPE_SFIXED32 {
                    description "";
                }
                enum TYPE_SFIXED64 {
                    description "";
                }
                enum TYPE_SINT32 {
                    description "";
                }
                enum TYPE_SINT64 {
                    description "";
                }
            }
            description
                "";
        }

        typedef Label {
            type enumeration {
                enum LABEL_OPTIONAL {
                    description "";
                }
                enum LABEL_REQUIRED {
                    description "";
                }
                enum LABEL_REPEATED {
                    description "";
                }
            }
            description
                "";
        }

    }

    grouping OneofDescriptorProto {
        description
            "Describes a oneof.";
        leaf name {
            type  string; 
            description
                "";
        }

        container options {
            uses  OneofOptions;

            description
                "";
        }

    }

    grouping EnumDescriptorProto {
        description
            "Describes an enum type.";
        leaf name {
            type  string; 
            description
                "";
        }

        list value {
            key "name";
            uses  EnumValueDescriptorProto;

            description
                "";
        }

        container options {
            uses  EnumOptions;

            description
                "";
        }

    }

    grouping EnumValueDescriptorProto {
        description
            "Describes a value within an enum.";
        leaf name {
            type  string; 
            description
                "";
        }

        leaf number {
            type  int32; 
            description
                "";
        }

        container options {
            uses  EnumValueOptions;

            description
                "";
        }

    }

    grouping ServiceDescriptorProto {
        description
            "Describes a service.";
        leaf name {
            type  string; 
            description
                "";
        }

        list method {
            key "name";
            uses  MethodDescriptorProto;

            description
                "";
        }

        container options {
            uses  ServiceOptions;

            description
                "";
        }

    }

    grouping MethodDescriptorProto {
        description
            "Describes a method of a service.";
        leaf name {
            type  string; 
            description
                "";
        }

        leaf input_type {
            type  string; 
            description
                "Input and output type names.  These are resolved in the same way as
 FieldDescriptorProto.type_name, but must refer to a message type.";
        }

        leaf output_type {
            type  string; 
            description
                "";
        }

        container options {
            uses  MethodOptions;

            description
                "";
        }

        leaf client_streaming {
            type  boolean; 
            description
                "Identifies if client streams multiple client messages";
        }

        leaf server_streaming {
            type  boolean; 
            description
                "Identifies if server streams multiple server messages";
        }

    }

    grouping FileOptions {
        description
            "===================================================================
 Options
Each of the definitions above may have  options  attached.  These are
 just annotations which may cause code to be generated slightly differently
 or may contain hints for code that manipulates protocol messages.

 Clients may define custom options as extensions of the  Options messages.
 These extensions may not yet be known at parsing time, so the parser cannot
 store the values in them.  Instead it stores them in a field in the  Options
 message called uninterpreted_option. This field must have the same name
 across all  Options messages. We then use this field to populate the
 extensions when we build a descriptor, at which point all protos have been
 parsed and so all extensions are known.

 Extension numbers for custom options may be chosen as follows:
   For options which will only be used within a single application or
   organization, or for experimental options, use field numbers 50000
   through 99999.  It is up to you to ensure that you do not use the
   same number for multiple options.
   For options which will be published and used publicly by multiple
   independent entities, e-mail protobuf-global-extension-registry@google.com
   to reserve extension numbers. Simply provide your project name (e.g.
   Objective-C plugin) and your project website (if available) -- there's no
   need to explain how you intend to use them. Usually you only need one
   extension number. You can declare multiple options with only one extension
   number by putting them in a sub-message. See the Custom Options section of
   the docs for examples:
   https:  developers.google.com protocol-buffers docs proto#options
   If this turns out to be popular, a web service will be set up
   to automatically assign option numbers.";
        leaf java_package {
            type  string; 
            description
                "Sets the Java package where classes generated from this .proto will be
 placed.  By default, the proto package is used, but this is often
 inappropriate because proto packages do not normally start with backwards
 domain names.";
        }

        leaf java_outer_classname {
            type  string; 
            description
                "If set, all the classes from the .proto file are wrapped in a single
 outer class with the given name.  This applies to both Proto1
 (equivalent to the old  --one_java_file  option) and Proto2 (where
 a .proto always translates to a single class, but you may want to
 explicitly choose the class name).";
        }

        leaf java_multiple_files {
            type  boolean; 
            description
                "If set true, then the Java code generator will generate a separate .java
 file for each top-level message, enum, and service defined in the .proto
 file.  Thus, these types will  not  be nested inside the outer class
 named by java_outer_classname.  However, the outer class will still be
 generated to contain the file's getDescriptor() method as well as any
 top-level extensions defined in the file.";
        }

        leaf java_generate_equals_and_hash {
            type  boolean; 
            description
                "If set true, then the Java code generator will generate equals() and
 hashCode() methods for all messages defined in the .proto file.
 This increases generated code size, potentially substantially for large
 protos, which may harm a memory-constrained application.
 - In the full runtime this is a speed optimization, as the
 AbstractMessage base class includes reflection-based implementations of
 these methods.
 - In the lite runtime, setting this option changes the semantics of
 equals() and hashCode() to more closely match those of the full runtime;
 the generated methods compute their results based on field values rather
 than object identity. (Implementations should not assume that hashcodes
 will be consistent across runtimes or versions of the protocol compiler.)";
        }

        leaf java_string_check_utf8 {
            type  boolean; 
            description
                "If set true, then the Java2 code generator will generate code that
 throws an exception whenever an attempt is made to assign a non-UTF-8
 byte sequence to a string field.
 Message reflection will do the same.
 However, an extension field still accepts non-UTF-8 byte sequences.
 This option has no effect on when used with the lite runtime.";
        }

        leaf optimize_for {
            type  OptimizeMode; 
            description
                "";
        }

        leaf go_package {
            type  string; 
            description
                "Sets the Go package where structs generated from this .proto will be
 placed. If omitted, the Go package will be derived from the following:
   - The basename of the package import path, if provided.
   - Otherwise, the package statement in the .proto file, if present.
   - Otherwise, the basename of the .proto file, without extension.";
        }

        leaf cc_generic_services {
            type  boolean; 
            description
                "Should generic services be generated in each language?   Generic  services
 are not specific to any particular RPC system.  They are generated by the
 main code generators in each language (without additional plugins).
 Generic services were the only kind of service generation supported by
 early versions of google.protobuf.

 Generic services are now considered deprecated in favor of using plugins
 that generate code specific to your particular RPC system.  Therefore,
 these default to false.  Old code which depends on generic services should
 explicitly set them to true.";
        }

        leaf java_generic_services {
            type  boolean; 
            description
                "";
        }

        leaf py_generic_services {
            type  boolean; 
            description
                "";
        }

        leaf deprecated {
            type  boolean; 
            description
                "Is this file deprecated?
 Depending on the target platform, this can emit Deprecated annotations
 for everything in the file, or it will be completely ignored; in the very
 least, this is a formalization for deprecating files.";
        }

        leaf cc_enable_arenas {
            type  boolean; 
            description
                "Enables the use of arenas for the proto messages in this file. This applies
 only to generated classes for C++.";
        }

        leaf objc_class_prefix {
            type  string; 
            description
                "Sets the objective c class prefix which is prepended to all objective c
 generated classes from this .proto. There is no default.";
        }

        leaf csharp_namespace {
            type  string; 
            description
                "Namespace for generated classes; defaults to the package.";
        }

        list uninterpreted_option {
            key "identifier_value";
            uses  UninterpretedOption;

            description
                "The parser stores options it doesn't recognize here. See above.";
        }

        typedef OptimizeMode {
            type enumeration {
                enum SPEED {
                    description "";
                }
                enum CODE_SIZE {
                    description "";
                }
                enum LITE_RUNTIME {
                    description "";
                }
            }
            description
                "Generated classes can be optimized for speed or code size.";
        }

    }

    grouping MessageOptions {
        description
            "";
        leaf message_set_wire_format {
            type  boolean; 
            description
                "Set true to use the old proto1 MessageSet wire format for extensions.
 This is provided for backwards-compatibility with the MessageSet wire
 format.  You should not use this for any other reason:  It's less
 efficient, has fewer features, and is more complicated.

 The message must be defined exactly as follows:
   message Foo  
     option message_set_wire_format = true;
     extensions 4 to max;
    
 Note that the message cannot have any defined fields; MessageSets only
 have extensions.

 All extensions of your type must be singular messages; e.g. they cannot
 be int32s, enums, or repeated messages.

 Because this is an option, the above two restrictions are not enforced by
 the protocol compiler.";
        }

        leaf no_standard_descriptor_accessor {
            type  boolean; 
            description
                "Disables the generation of the standard  descriptor()  accessor, which can
 conflict with a field of the same name.  This is meant to make migration
 from proto1 easier; new code should avoid fields named  descriptor .";
        }

        leaf deprecated {
            type  boolean; 
            description
                "Is this message deprecated?
 Depending on the target platform, this can emit Deprecated annotations
 for the message, or it will be completely ignored; in the very least,
 this is a formalization for deprecating messages.";
        }

        leaf map_entry {
            type  boolean; 
            description
                "Whether the message is an automatically generated map entry type for the
 maps field.

 For maps fields:
     map<KeyType, ValueType> map_field = 1;
 The parsed descriptor looks like:
     message MapFieldEntry  
         option map_entry = true;
         optional KeyType key = 1;
         optional ValueType value = 2;
      
     repeated MapFieldEntry map_field = 1;

 Implementations may choose not to generate the map_entry=true message, but
 use a native map in the target language to hold the keys and values.
 The reflection APIs in such implementions still need to work as
 if the field is a repeated message field.

 NOTE: Do not set the option in .proto files. Always use the maps syntax
 instead. The option should only be implicitly set by the proto compiler
 parser.";
        }

        list uninterpreted_option {
            key "identifier_value";
            uses  UninterpretedOption;

            description
                "The parser stores options it doesn't recognize here. See above.";
        }

    }

    grouping FieldOptions {
        description
            "";
        leaf ctype {
            type  CType; 
            description
                "The ctype option instructs the C++ code generator to use a different
 representation of the field than it normally would.  See the specific
 options below.  This option is not yet implemented in the open source
 release -- sorry, we'll try to include it in a future version!";
        }

        leaf packed {
            type  boolean; 
            description
                "The packed option can be enabled for repeated primitive fields to enable
 a more efficient representation on the wire. Rather than repeatedly
 writing the tag and type for each element, the entire array is encoded as
 a single length-delimited blob. In proto3, only explicit setting it to
 false will avoid using packed encoding.";
        }

        leaf jstype {
            type  JSType; 
            description
                "The jstype option determines the JavaScript type used for values of the
 field.  The option is permitted only for 64 bit integral and fixed types
 (int64, uint64, sint64, fixed64, sfixed64).  By default these types are
 represented as JavaScript strings.  This avoids loss of precision that can
 happen when a large value is converted to a floating point JavaScript
 numbers.  Specifying JS_NUMBER for the jstype causes the generated
 JavaScript code to use the JavaScript  number  type instead of strings.
 This option is an enum to permit additional types to be added,
 e.g. goog.math.Integer.";
        }

        leaf lazy {
            type  boolean; 
            description
                "Should this field be parsed lazily?  Lazy applies only to message-type
 fields.  It means that when the outer message is initially parsed, the
 inner message's contents will not be parsed but instead stored in encoded
 form.  The inner message will actually be parsed when it is first accessed.

 This is only a hint.  Implementations are free to choose whether to use
 eager or lazy parsing regardless of the value of this option.  However,
 setting this option true suggests that the protocol author believes that
 using lazy parsing on this field is worth the additional bookkeeping
 overhead typically needed to implement it.

 This option does not affect the public interface of any generated code;
 all method signatures remain the same.  Furthermore, thread-safety of the
 interface is not affected by this option; const methods remain safe to
 call from multiple threads concurrently, while non-const methods continue
 to require exclusive access.


 Note that implementations may choose not to check required fields within
 a lazy sub-message.  That is, calling IsInitialized() on the outher message
 may return true even if the inner message has missing required fields.
 This is necessary because otherwise the inner message would have to be
 parsed in order to perform the check, defeating the purpose of lazy
 parsing.  An implementation which chooses not to check required fields
 must be consistent about it.  That is, for any particular sub-message, the
 implementation must either  always  check its required fields, or  never 
 check its required fields, regardless of whether or not the message has
 been parsed.";
        }

        leaf deprecated {
            type  boolean; 
            description
                "Is this field deprecated?
 Depending on the target platform, this can emit Deprecated annotations
 for accessors, or it will be completely ignored; in the very least, this
 is a formalization for deprecating fields.";
        }

        leaf weak {
            type  boolean; 
            description
                "For Google-internal migration only. Do not use.";
        }

        list uninterpreted_option {
            key "identifier_value";
            uses  UninterpretedOption;

            description
                "The parser stores options it doesn't recognize here. See above.";
        }

        typedef CType {
            type enumeration {
                enum STRING {
                    description "";
                }
                enum CORD {
                    description "";
                }
                enum STRING_PIECE {
                    description "";
                }
            }
            description
                "";
        }

        typedef JSType {
            type enumeration {
                enum JS_NORMAL {
                    description "";
                }
                enum JS_STRING {
                    description "";
                }
                enum JS_NUMBER {
                    description "";
                }
            }
            description
                "";
        }

    }

    grouping OneofOptions {
        description
            "";
        list uninterpreted_option {
            key "identifier_value";
            uses  UninterpretedOption;

            description
                "The parser stores options it doesn't recognize here. See above.";
        }

    }

    grouping EnumOptions {
        description
            "";
        leaf allow_alias {
            type  boolean; 
            description
                "Set this option to true to allow mapping different tag names to the same
 value.";
        }

        leaf deprecated {
            type  boolean; 
            description
                "Is this enum deprecated?
 Depending on the target platform, this can emit Deprecated annotations
 for the enum, or it will be completely ignored; in the very least, this
 is a formalization for deprecating enums.";
        }

        list uninterpreted_option {
            key "identifier_value";
            uses  UninterpretedOption;

            description
                "The parser stores options it doesn't recognize here. See above.";
        }

    }

    grouping EnumValueOptions {
        description
            "";
        leaf deprecated {
            type  boolean; 
            description
                "Is this enum value deprecated?
 Depending on the target platform, this can emit Deprecated annotations
 for the enum value, or it will be completely ignored; in the very least,
 this is a formalization for deprecating enum values.";
        }

        list uninterpreted_option {
            key "identifier_value";
            uses  UninterpretedOption;

            description
                "The parser stores options it doesn't recognize here. See above.";
        }

    }

    grouping ServiceOptions {
        description
            "";
        leaf deprecated {
            type  boolean; 
            description
                "Is this service deprecated?
 Depending on the target platform, this can emit Deprecated annotations
 for the service, or it will be completely ignored; in the very least,
 this is a formalization for deprecating services.
Note:  Field numbers 1 through 32 are reserved for Google's internal RPC
   framework.  We apologize for hoarding these numbers to ourselves, but
   we were already using them long before we decided to release Protocol
   Buffers.";
        }

        list uninterpreted_option {
            key "identifier_value";
            uses  UninterpretedOption;

            description
                "The parser stores options it doesn't recognize here. See above.";
        }

    }

    grouping MethodOptions {
        description
            "";
        leaf deprecated {
            type  boolean; 
            description
                "Is this method deprecated?
 Depending on the target platform, this can emit Deprecated annotations
 for the method, or it will be completely ignored; in the very least,
 this is a formalization for deprecating methods.
Note:  Field numbers 1 through 32 are reserved for Google's internal RPC
   framework.  We apologize for hoarding these numbers to ourselves, but
   we were already using them long before we decided to release Protocol
   Buffers.";
        }

        list uninterpreted_option {
            key "identifier_value";
            uses  UninterpretedOption;

            description
                "The parser stores options it doesn't recognize here. See above.";
        }

    }

    grouping UninterpretedOption {
        description
            "A message representing a option the parser does not recognize. This only
 appears in options protos created by the compiler::Parser class.
 DescriptorPool resolves these when building Descriptor objects. Therefore,
 options protos in descriptor objects (e.g. returned by Descriptor::options(),
 or produced by Descriptor::CopyTo()) will never have UninterpretedOptions
 in them.";

        leaf identifier_value {
            type  string; 
            description
                "The value of the uninterpreted option, in whatever type the tokenizer
 identified it as during parsing. Exactly one of these should be set.";
        }

        leaf positive_int_value {
            type  uint64; 
            description
                "";
        }

        leaf negative_int_value {
            type  int64; 
            description
                "";
        }

        leaf double_value {
            type decimal64 {
               fraction-digits 5;
            }
            description
                "";
        }

        leaf string_value {
            type  binary; 
            description
                "";
        }

        leaf aggregate_value {
            type  string; 
            description
                "";
        }

        grouping NamePart {
            description
                "The name of the uninterpreted option.  Each string represents a segment in
     a dot-separated name.  is_extension is true iff a segment represents an
     extension (denoted with parentheses in options specs in .proto files).
     E.g.,    foo , false ,   bar.baz , true ,   qux , false    represents
      foo.(bar.baz).qux .";
            leaf name_part {
                type  string; 
                description
                    "";
            }
    
            leaf is_extension {
                type  boolean; 
                description
                    "";
            }
    
        }
    
    }

    grouping SourceCodeInfo {
        description
            "Encapsulates information about the original source file from which a
 FileDescriptorProto was generated.
===================================================================
 Optional source code info";

        grouping Location {
            description
                "";
            list path {
                key "path";
                leaf path {
                    type  int32; 
                    description
                        "Identifies which part of the FileDescriptorProto was defined at this
     location.
    
     Each element is a field number or an index.  They form a path from
     the root FileDescriptorProto to the place where the definition.  For
     example, this path:
         4, 3, 2, 7, 1  
     refers to:
       file.message_type(3)     4, 3
           .field(7)            2, 7
           .name()              1
     This is because FileDescriptorProto.message_type has field number 4:
       repeated DescriptorProto message_type = 4;
     and DescriptorProto.field has field number 2:
       repeated FieldDescriptorProto field = 2;
     and FieldDescriptorProto.name has field number 1:
       optional string name = 1;
    
     Thus, the above path gives the location of a field name.  If we removed
     the last element:
         4, 3, 2, 7  
     this path refers to the whole field declaration (from the beginning
     of the label to the terminating semicolon).";
                }
                description
                    "Identifies which part of the FileDescriptorProto was defined at this
     location.
    
     Each element is a field number or an index.  They form a path from
     the root FileDescriptorProto to the place where the definition.  For
     example, this path:
         4, 3, 2, 7, 1  
     refers to:
       file.message_type(3)     4, 3
           .field(7)            2, 7
           .name()              1
     This is because FileDescriptorProto.message_type has field number 4:
       repeated DescriptorProto message_type = 4;
     and DescriptorProto.field has field number 2:
       repeated FieldDescriptorProto field = 2;
     and FieldDescriptorProto.name has field number 1:
       optional string name = 1;
    
     Thus, the above path gives the location of a field name.  If we removed
     the last element:
         4, 3, 2, 7  
     this path refers to the whole field declaration (from the beginning
     of the label to the terminating semicolon).";
            }
    
            list span {
                key "span";
                leaf span {
                    type  int32; 
                    description
                        "Always has exactly three or four elements: start line, start column,
     end line (optional, otherwise assumed same as start line), end column.
     These are packed into a single field for efficiency.  Note that line
     and column numbers are zero-based -- typically you will want to add
     1 to each before displaying to a user.";
                }
                description
                    "Always has exactly three or four elements: start line, start column,
     end line (optional, otherwise assumed same as start line), end column.
     These are packed into a single field for efficiency.  Note that line
     and column numbers are zero-based -- typically you will want to add
     1 to each before displaying to a user.";
            }
    
            leaf leading_comments {
                type  string; 
                description
                    "If this SourceCodeInfo represents a complete declaration, these are any
     comments appearing before and after the declaration which appear to be
     attached to the declaration.
    
     A series of line comments appearing on consecutive lines, with no other
     tokens appearing on those lines, will be treated as a single comment.
    
     leading_detached_comments will keep paragraphs of comments that appear
     before (but not connected to) the current element. Each paragraph,
     separated by empty lines, will be one comment element in the repeated
     field.
    
     Only the comment content is provided; comment markers (e.g.   ) are
     stripped out.  For block comments, leading whitespace and an asterisk
     will be stripped from the beginning of each line other than the first.
     Newlines are included in the output.
    
     Examples:
    
       optional int32 foo = 1;     Comment attached to foo.
          Comment attached to bar.
       optional int32 bar = 2;
    
       optional string baz = 3;
          Comment attached to baz.
          Another line attached to baz.
    
          Comment attached to qux.
         
          Another line attached to qux.
       optional double qux = 4;
    
          Detached comment for corge. This is not leading or trailing comments
          to qux or corge because there are blank lines separating it from
          both.
    
          Detached comment for corge paragraph 2.
    
       optional string corge = 5;
          Block comment attached
          to corge.  Leading asterisks
          will be removed.   
          Block comment attached to
          grault.   
       optional int32 grault = 6;
    
          ignored detached comments.";
            }
    
            leaf trailing_comments {
                type  string; 
                description
                    "";
            }
    
            list leading_detached_comments {
                key "leading_detached_comments";
                leaf leading_detached_comments {
                    type  string; 
                    description
                        "";
                }
                description
                    "";
            }
    
        }
    
    }

    container GeneratedCodeInfo {
        description
            "Describes the relationship between generated code and its original source
 file. A GeneratedCodeInfo message is associated with only one generated
 source file, but may contain references to different source .proto files.";

        grouping Annotation {
            description
                "";
            list path {
                key "path";
                leaf path {
                    type  int32; 
                    description
                        "Identifies the element in the original source .proto file. This field
     is formatted the same as SourceCodeInfo.Location.path.";
                }
                description
                    "Identifies the element in the original source .proto file. This field
     is formatted the same as SourceCodeInfo.Location.path.";
            }
    
            leaf source_file {
                type  string; 
                description
                    "Identifies the filesystem path to the original source .proto.";
            }
    
            leaf begin {
                type  int32; 
                description
                    "Identifies the starting offset in bytes in the generated code
     that relates to the identified object.";
            }
    
            leaf end {
                type  int32; 
                description
                    "Identifies the ending offset in bytes in the generated code that
     relates to the identified offset. The end offset should be one past
     the last relevant byte (so the length of the text = end - begin).";
            }
    
        }
    
    }

}