diff --git a/experiments/netconf/proto2yang/ietf-descriptor.yang b/experiments/netconf/proto2yang/ietf-descriptor.yang
new file mode 100644
index 0000000..487f100
--- /dev/null
+++ b/experiments/netconf/proto2yang/ietf-descriptor.yang
@@ -0,0 +1,1331 @@
+
+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).";
+            }
+    
+        }
+    
+    }
+
+}
\ No newline at end of file