proto-lens 0.2.2.0 → 0.3.0.0

raw patch · 14 files changed

+7137/−235 lines, 14 filesdep +deepseqdep +lens-labelsPVP ok

version bump matches the API change (PVP)

Dependencies added: deepseq, lens-labels

API changes (from Hackage documentation)

Files

• Changelog.md +17/−1
• proto-lens-imports/google/protobuf/compiler/plugin.proto +150/−0
• proto-lens-imports/google/protobuf/descriptor.proto +803/−0
• proto-lens.cabal +69/−42
• src/Data/ProtoLens/Encoding.hs +79/−47
• src/Data/ProtoLens/Encoding/Wire.hs +65/−15
• src/Data/ProtoLens/Message.hs +116/−41
• src/Data/ProtoLens/Service/Types.hs +126/−0
• src/Data/ProtoLens/TextFormat.hs +167/−84
• src/Data/ProtoLens/TextFormat/Parser.hs +15/−5
• src/Proto/Google/Protobuf/Compiler/Plugin.hs +345/−0
• src/Proto/Google/Protobuf/Compiler/Plugin_Fields.hs +109/−0
• src/Proto/Google/Protobuf/Descriptor.hs +4182/−0
• src/Proto/Google/Protobuf/Descriptor_Fields.hs +894/−0

@@ -1,6 +1,22 @@ # Changelog for `proto-lens` -## Unreleased changes+## v0.3.0.0+- Remove support for `ghc-7.10`. (#136)+- Use a `.cabal` file that's auto-generated from `hpack`. (#138)+- Add buildMessageDelimited: size-delimited streams of Messages (#102)+- Add support for parsing `Any` messages in google protobuf text format (#124)+- Use the Tag newtype consistently. (#127)+- Add support for tracking unknown fields. (#129)+- Improve an error message. (#132)+- Bundle enum pattern synonyms with their type. (#136)+- Implement proto3-style "open" enums. (#137)+- Consolidate `proto-lens-descriptors` into `proto-lens`. (#140)+- Split the `Message` class into separate methods. (#139)+- Improve an error message when decoding Anys. (#146)+- Refactor the `FieldDescriptorType. (#147)+- Improve text format error messages. (#148)+- Add module `Data.ProtoLens.Service.Types`. (#154)+- Add Haddock comments to fields. (#172)  ## v0.2.2.0 - Bump the dependency on `base` to support `ghc-8.2.1`.

@@ -0,0 +1,150 @@+// Protocol Buffers - Google's data interchange format+// Copyright 2008 Google Inc.  All rights reserved.+// https://developers.google.com/protocol-buffers/+//+// Redistribution and use in source and binary forms, with or without+// modification, are permitted provided that the following conditions are+// met:+//+//     * Redistributions of source code must retain the above copyright+// notice, this list of conditions and the following disclaimer.+//     * Redistributions in binary form must reproduce the above+// copyright notice, this list of conditions and the following disclaimer+// in the documentation and/or other materials provided with the+// distribution.+//     * Neither the name of Google Inc. nor the names of its+// contributors may be used to endorse or promote products derived from+// this software without specific prior written permission.+//+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.++// Author: kenton@google.com (Kenton Varda)+//+// WARNING:  The plugin interface is currently EXPERIMENTAL and is subject to+//   change.+//+// protoc (aka the Protocol Compiler) can be extended via plugins.  A plugin is+// just a program that reads a CodeGeneratorRequest from stdin and writes a+// CodeGeneratorResponse to stdout.+//+// Plugins written using C++ can use google/protobuf/compiler/plugin.h instead+// of dealing with the raw protocol defined here.+//+// A plugin executable needs only to be placed somewhere in the path.  The+// plugin should be named "protoc-gen-$NAME", and will then be used when the+// flag "--${NAME}_out" is passed to protoc.++syntax = "proto2";+package google.protobuf.compiler;+option java_package = "com.google.protobuf.compiler";+option java_outer_classname = "PluginProtos";++option go_package = "plugin_go";++import "google/protobuf/descriptor.proto";++// An encoded CodeGeneratorRequest is written to the plugin's stdin.+message CodeGeneratorRequest {+  // The .proto files that were explicitly listed on the command-line.  The+  // code generator should generate code only for these files.  Each file's+  // descriptor will be included in proto_file, below.+  repeated string file_to_generate = 1;++  // The generator parameter passed on the command-line.+  optional string parameter = 2;++  // FileDescriptorProtos for all files in files_to_generate and everything+  // they import.  The files will appear in topological order, so each file+  // appears before any file that imports it.+  //+  // protoc guarantees that all proto_files will be written after+  // the fields above, even though this is not technically guaranteed by the+  // protobuf wire format.  This theoretically could allow a plugin to stream+  // in the FileDescriptorProtos and handle them one by one rather than read+  // the entire set into memory at once.  However, as of this writing, this+  // is not similarly optimized on protoc's end -- it will store all fields in+  // memory at once before sending them to the plugin.+  repeated FileDescriptorProto proto_file = 15;+}++// The plugin writes an encoded CodeGeneratorResponse to stdout.+message CodeGeneratorResponse {+  // Error message.  If non-empty, code generation failed.  The plugin process+  // should exit with status code zero even if it reports an error in this way.+  //+  // This should be used to indicate errors in .proto files which prevent the+  // code generator from generating correct code.  Errors which indicate a+  // problem in protoc itself -- such as the input CodeGeneratorRequest being+  // unparseable -- should be reported by writing a message to stderr and+  // exiting with a non-zero status code.+  optional string error = 1;++  // Represents a single generated file.+  message File {+    // The file name, relative to the output directory.  The name must not+    // contain "." or ".." components and must be relative, not be absolute (so,+    // the file cannot lie outside the output directory).  "/" must be used as+    // the path separator, not "\".+    //+    // If the name is omitted, the content will be appended to the previous+    // file.  This allows the generator to break large files into small chunks,+    // and allows the generated text to be streamed back to protoc so that large+    // files need not reside completely in memory at one time.  Note that as of+    // this writing protoc does not optimize for this -- it will read the entire+    // CodeGeneratorResponse before writing files to disk.+    optional string name = 1;++    // If non-empty, indicates that the named file should already exist, and the+    // content here is to be inserted into that file at a defined insertion+    // point.  This feature allows a code generator to extend the output+    // produced by another code generator.  The original generator may provide+    // insertion points by placing special annotations in the file that look+    // like:+    //   @@protoc_insertion_point(NAME)+    // The annotation can have arbitrary text before and after it on the line,+    // which allows it to be placed in a comment.  NAME should be replaced with+    // an identifier naming the point -- this is what other generators will use+    // as the insertion_point.  Code inserted at this point will be placed+    // immediately above the line containing the insertion point (thus multiple+    // insertions to the same point will come out in the order they were added).+    // The double-@ is intended to make it unlikely that the generated code+    // could contain things that look like insertion points by accident.+    //+    // For example, the C++ code generator places the following line in the+    // .pb.h files that it generates:+    //   // @@protoc_insertion_point(namespace_scope)+    // This line appears within the scope of the file's package namespace, but+    // outside of any particular class.  Another plugin can then specify the+    // insertion_point "namespace_scope" to generate additional classes or+    // other declarations that should be placed in this scope.+    //+    // Note that if the line containing the insertion point begins with+    // whitespace, the same whitespace will be added to every line of the+    // inserted text.  This is useful for languages like Python, where+    // indentation matters.  In these languages, the insertion point comment+    // should be indented the same amount as any inserted code will need to be+    // in order to work correctly in that context.+    //+    // The code generator that generates the initial file and the one which+    // inserts into it must both run as part of a single invocation of protoc.+    // Code generators are executed in the order in which they appear on the+    // command line.+    //+    // If |insertion_point| is present, |name| must also be present.+    optional string insertion_point = 2;++    // The file contents.+    optional string content = 15;+  }+  repeated File file = 15;+}

@@ -0,0 +1,803 @@+// Protocol Buffers - Google's data interchange format+// Copyright 2008 Google Inc.  All rights reserved.+// https://developers.google.com/protocol-buffers/+//+// Redistribution and use in source and binary forms, with or without+// modification, are permitted provided that the following conditions are+// met:+//+//     * Redistributions of source code must retain the above copyright+// notice, this list of conditions and the following disclaimer.+//     * Redistributions in binary form must reproduce the above+// copyright notice, this list of conditions and the following disclaimer+// in the documentation and/or other materials provided with the+// distribution.+//     * Neither the name of Google Inc. nor the names of its+// contributors may be used to endorse or promote products derived from+// this software without specific prior written permission.+//+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.++// Author: kenton@google.com (Kenton Varda)+//  Based on original Protocol Buffers design by+//  Sanjay Ghemawat, Jeff Dean, and others.+//+// The messages in this file describe the definitions found in .proto files.+// A valid .proto file can be translated directly to a FileDescriptorProto+// without any other information (e.g. without reading its imports).+++syntax = "proto2";++package google.protobuf;+option go_package = "descriptor";+option java_package = "com.google.protobuf";+option java_outer_classname = "DescriptorProtos";+option csharp_namespace = "Google.Protobuf.Reflection";+option objc_class_prefix = "GPB";++// descriptor.proto must be optimized for speed because reflection-based+// algorithms don't work during bootstrapping.+option optimize_for = SPEED;++// The protocol compiler can output a FileDescriptorSet containing the .proto+// files it parses.+message FileDescriptorSet {+  repeated FileDescriptorProto file = 1;+}++// Describes a complete .proto file.+message FileDescriptorProto {+  optional string name = 1;       // file name, relative to root of source tree+  optional string package = 2;    // e.g. "foo", "foo.bar", etc.++  // Names of files imported by this file.+  repeated string dependency = 3;+  // Indexes of the public imported files in the dependency list above.+  repeated int32 public_dependency = 10;+  // Indexes of the weak imported files in the dependency list.+  // For Google-internal migration only. Do not use.+  repeated int32 weak_dependency = 11;++  // All top-level definitions in this file.+  repeated DescriptorProto message_type = 4;+  repeated EnumDescriptorProto enum_type = 5;+  repeated ServiceDescriptorProto service = 6;+  repeated FieldDescriptorProto extension = 7;++  optional FileOptions options = 8;++  // 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.+  optional SourceCodeInfo source_code_info = 9;++  // The syntax of the proto file.+  // The supported values are "proto2" and "proto3".+  optional string syntax = 12;+}++// Describes a message type.+message DescriptorProto {+  optional string name = 1;++  repeated FieldDescriptorProto field = 2;+  repeated FieldDescriptorProto extension = 6;++  repeated DescriptorProto nested_type = 3;+  repeated EnumDescriptorProto enum_type = 4;++  message ExtensionRange {+    optional int32 start = 1;+    optional int32 end = 2;+  }+  repeated ExtensionRange extension_range = 5;++  repeated OneofDescriptorProto oneof_decl = 8;++  optional MessageOptions options = 7;++  // 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.+  message ReservedRange {+    optional int32 start = 1; // Inclusive.+    optional int32 end = 2;   // Exclusive.+  }+  repeated ReservedRange reserved_range = 9;+  // Reserved field names, which may not be used by fields in the same message.+  // A given name may only be reserved once.+  repeated string reserved_name = 10;+}++// Describes a field within a message.+message FieldDescriptorProto {+  enum Type {+    // 0 is reserved for errors.+    // Order is weird for historical reasons.+    TYPE_DOUBLE         = 1;+    TYPE_FLOAT          = 2;+    // Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT64 if+    // negative values are likely.+    TYPE_INT64          = 3;+    TYPE_UINT64         = 4;+    // Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT32 if+    // negative values are likely.+    TYPE_INT32          = 5;+    TYPE_FIXED64        = 6;+    TYPE_FIXED32        = 7;+    TYPE_BOOL           = 8;+    TYPE_STRING         = 9;+    TYPE_GROUP          = 10;  // Tag-delimited aggregate.+    TYPE_MESSAGE        = 11;  // Length-delimited aggregate.++    // New in version 2.+    TYPE_BYTES          = 12;+    TYPE_UINT32         = 13;+    TYPE_ENUM           = 14;+    TYPE_SFIXED32       = 15;+    TYPE_SFIXED64       = 16;+    TYPE_SINT32         = 17;  // Uses ZigZag encoding.+    TYPE_SINT64         = 18;  // Uses ZigZag encoding.+  };++  enum Label {+    // 0 is reserved for errors+    LABEL_OPTIONAL      = 1;+    LABEL_REQUIRED      = 2;+    LABEL_REPEATED      = 3;+    // TODO(sanjay): Should we add LABEL_MAP?+  };++  optional string name = 1;+  optional int32 number = 3;+  optional Label label = 4;++  // 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.+  optional Type type = 5;++  // 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).+  optional string type_name = 6;++  // For extensions, this is the name of the type being extended.  It is+  // resolved in the same manner as type_name.+  optional string extendee = 2;++  // 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?+  optional string default_value = 7;++  // If set, gives the index of a oneof in the containing type's oneof_decl+  // list.  This field is a member of that oneof.+  optional int32 oneof_index = 9;++  // 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.+  optional string json_name = 10;++  optional FieldOptions options = 8;+}++// Describes a oneof.+message OneofDescriptorProto {+  optional string name = 1;+}++// Describes an enum type.+message EnumDescriptorProto {+  optional string name = 1;++  repeated EnumValueDescriptorProto value = 2;++  optional EnumOptions options = 3;+}++// Describes a value within an enum.+message EnumValueDescriptorProto {+  optional string name = 1;+  optional int32 number = 2;++  optional EnumValueOptions options = 3;+}++// Describes a service.+message ServiceDescriptorProto {+  optional string name = 1;+  repeated MethodDescriptorProto method = 2;++  optional ServiceOptions options = 3;+}++// Describes a method of a service.+message MethodDescriptorProto {+  optional string name = 1;++  // Input and output type names.  These are resolved in the same way as+  // FieldDescriptorProto.type_name, but must refer to a message type.+  optional string input_type = 2;+  optional string output_type = 3;++  optional MethodOptions options = 4;++  // Identifies if client streams multiple client messages+  optional bool client_streaming = 5 [default=false];+  // Identifies if server streams multiple server messages+  optional bool server_streaming = 6 [default=false];+}+++// ===================================================================+// 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.+++message FileOptions {++  // 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.+  optional string java_package = 1;+++  // 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).+  optional string java_outer_classname = 8;++  // 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.+  optional bool java_multiple_files = 10 [default=false];++  // 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.)+  optional bool java_generate_equals_and_hash = 20 [default=false];++  // 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.+  optional bool java_string_check_utf8 = 27 [default=false];+++  // Generated classes can be optimized for speed or code size.+  enum OptimizeMode {+    SPEED = 1;        // Generate complete code for parsing, serialization,+                      // etc.+    CODE_SIZE = 2;    // Use ReflectionOps to implement these methods.+    LITE_RUNTIME = 3; // Generate code using MessageLite and the lite runtime.+  }+  optional OptimizeMode optimize_for = 9 [default=SPEED];++  // 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.+  optional string go_package = 11;++++  // 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.+  optional bool cc_generic_services = 16 [default=false];+  optional bool java_generic_services = 17 [default=false];+  optional bool py_generic_services = 18 [default=false];++  // 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.+  optional bool deprecated = 23 [default=false];++  // Enables the use of arenas for the proto messages in this file. This applies+  // only to generated classes for C++.+  optional bool cc_enable_arenas = 31 [default=false];+++  // Sets the objective c class prefix which is prepended to all objective c+  // generated classes from this .proto. There is no default.+  optional string objc_class_prefix = 36;++  // Namespace for generated classes; defaults to the package.+  optional string csharp_namespace = 37;++  // The parser stores options it doesn't recognize here. See above.+  repeated UninterpretedOption uninterpreted_option = 999;++  // Clients can define custom options in extensions of this message. See above.+  extensions 1000 to max;++  reserved 38;+}++message MessageOptions {+  // 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.+  optional bool message_set_wire_format = 1 [default=false];++  // 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".+  optional bool no_standard_descriptor_accessor = 2 [default=false];++  // 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.+  optional bool deprecated = 3 [default=false];++  // 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.+  optional bool map_entry = 7;++  // The parser stores options it doesn't recognize here. See above.+  repeated UninterpretedOption uninterpreted_option = 999;++  // Clients can define custom options in extensions of this message. See above.+  extensions 1000 to max;+}++message FieldOptions {+  // 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!+  optional CType ctype = 1 [default = STRING];+  enum CType {+    // Default mode.+    STRING = 0;++    CORD = 1;++    STRING_PIECE = 2;+  }+  // 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.+  optional bool packed = 2;+++  // 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.+  optional JSType jstype = 6 [default = JS_NORMAL];+  enum JSType {+    // Use the default type.+    JS_NORMAL = 0;++    // Use JavaScript strings.+    JS_STRING = 1;++    // Use JavaScript numbers.+    JS_NUMBER = 2;+  }++  // 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.+  optional bool lazy = 5 [default=false];++  // 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.+  optional bool deprecated = 3 [default=false];++  // For Google-internal migration only. Do not use.+  optional bool weak = 10 [default=false];+++  // The parser stores options it doesn't recognize here. See above.+  repeated UninterpretedOption uninterpreted_option = 999;++  // Clients can define custom options in extensions of this message. See above.+  extensions 1000 to max;+}++message EnumOptions {++  // Set this option to true to allow mapping different tag names to the same+  // value.+  optional bool allow_alias = 2;++  // 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.+  optional bool deprecated = 3 [default=false];++  // The parser stores options it doesn't recognize here. See above.+  repeated UninterpretedOption uninterpreted_option = 999;++  // Clients can define custom options in extensions of this message. See above.+  extensions 1000 to max;+}++message EnumValueOptions {+  // 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.+  optional bool deprecated = 1 [default=false];++  // The parser stores options it doesn't recognize here. See above.+  repeated UninterpretedOption uninterpreted_option = 999;++  // Clients can define custom options in extensions of this message. See above.+  extensions 1000 to max;+}++message ServiceOptions {++  // 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.++  // 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.+  optional bool deprecated = 33 [default=false];++  // The parser stores options it doesn't recognize here. See above.+  repeated UninterpretedOption uninterpreted_option = 999;++  // Clients can define custom options in extensions of this message. See above.+  extensions 1000 to max;+}++message MethodOptions {++  // 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.++  // 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.+  optional bool deprecated = 33 [default=false];++  // The parser stores options it doesn't recognize here. See above.+  repeated UninterpretedOption uninterpreted_option = 999;++  // Clients can define custom options in extensions of this message. See above.+  extensions 1000 to max;+}+++// 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.+message UninterpretedOption {+  // 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".+  message NamePart {+    required string name_part = 1;+    required bool is_extension = 2;+  }+  repeated NamePart name = 2;++  // The value of the uninterpreted option, in whatever type the tokenizer+  // identified it as during parsing. Exactly one of these should be set.+  optional string identifier_value = 3;+  optional uint64 positive_int_value = 4;+  optional int64 negative_int_value = 5;+  optional double double_value = 6;+  optional bytes string_value = 7;+  optional string aggregate_value = 8;+}++// ===================================================================+// Optional source code info++// Encapsulates information about the original source file from which a+// FileDescriptorProto was generated.+message SourceCodeInfo {+  // A Location identifies a piece of source code in a .proto file which+  // corresponds to a particular definition.  This information is intended+  // to be useful to IDEs, code indexers, documentation generators, and similar+  // tools.+  //+  // For example, say we have a file like:+  //   message Foo {+  //     optional string foo = 1;+  //   }+  // Let's look at just the field definition:+  //   optional string foo = 1;+  //   ^       ^^     ^^  ^  ^^^+  //   a       bc     de  f  ghi+  // We have the following locations:+  //   span   path               represents+  //   [a,i)  [ 4, 0, 2, 0 ]     The whole field definition.+  //   [a,b)  [ 4, 0, 2, 0, 4 ]  The label (optional).+  //   [c,d)  [ 4, 0, 2, 0, 5 ]  The type (string).+  //   [e,f)  [ 4, 0, 2, 0, 1 ]  The name (foo).+  //   [g,h)  [ 4, 0, 2, 0, 3 ]  The number (1).+  //+  // Notes:+  // - A location may refer to a repeated field itself (i.e. not to any+  //   particular index within it).  This is used whenever a set of elements are+  //   logically enclosed in a single code segment.  For example, an entire+  //   extend block (possibly containing multiple extension definitions) will+  //   have an outer location whose path refers to the "extensions" repeated+  //   field without an index.+  // - Multiple locations may have the same path.  This happens when a single+  //   logical declaration is spread out across multiple places.  The most+  //   obvious example is the "extend" block again -- there may be multiple+  //   extend blocks in the same scope, each of which will have the same path.+  // - A location's span is not always a subset of its parent's span.  For+  //   example, the "extendee" of an extension declaration appears at the+  //   beginning of the "extend" block and is shared by all extensions within+  //   the block.+  // - Just because a location's span is a subset of some other location's span+  //   does not mean that it is a descendent.  For example, a "group" defines+  //   both a type and a field in a single declaration.  Thus, the locations+  //   corresponding to the type and field and their components will overlap.+  // - Code which tries to interpret locations should probably be designed to+  //   ignore those that it doesn't understand, as more types of locations could+  //   be recorded in the future.+  repeated Location location = 1;+  message Location {+    // 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).+    repeated int32 path = 1 [packed=true];++    // 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.+    repeated int32 span = 2 [packed=true];++    // 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.+    optional string leading_comments = 3;+    optional string trailing_comments = 4;+    repeated string leading_detached_comments = 6;+  }+}++// 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.+message GeneratedCodeInfo {+  // An Annotation connects some span of text in generated code to an element+  // of its generating .proto file.+  repeated Annotation annotation = 1;+  message Annotation {+    // Identifies the element in the original source .proto file. This field+    // is formatted the same as SourceCodeInfo.Location.path.+    repeated int32 path = 1 [packed=true];++    // Identifies the filesystem path to the original source .proto.+    optional string source_file = 2;++    // Identifies the starting offset in bytes in the generated code+    // that relates to the identified object.+    optional int32 begin = 3;++    // 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).+    optional int32 end = 4;+  }+}

@@ -1,45 +1,72 @@-name:                proto-lens-version:             0.2.2.0-synopsis:            A lens-based implementation of protocol buffers in Haskell.-description:-  The proto-lens library provides to protocol buffers using modern-  Haskell language and library patterns.  Specifically, it provides:-  .-  * Composable field accessors via lenses-  .-  * Simple field name resolution/overloading via type-level literals-  .-  * Type-safe reflection and encoding/decoding of messages via GADTs+-- This file has been generated from package.yaml by hpack version 0.20.0.+--+-- see: https://github.com/sol/hpack+--+-- hash: f4741b76c0ffaab3c07146f386e2d9d450fa3c819af4f8631f11b4abf8f1feb4 -homepage:            https://github.com/google/proto-lens-license:             BSD3-license-file:        LICENSE-author:              Judah Jacobson-maintainer:          proto-lens@googlegroups.com-copyright:           Google Inc.-category:            Data-build-type:          Simple-cabal-version:       >=1.8-extra-source-files:  Changelog.md+name:           proto-lens+version:        0.3.0.0+synopsis:       A lens-based implementation of protocol buffers in Haskell.+description:    The proto-lens library provides to protocol buffers using modern Haskell language and library patterns.  Specifically, it provides:+                .+                * Composable field accessors via lenses+                .+                * Simple field name resolution/overloading via type-level literals+                .+                * Type-safe reflection and encoding/decoding of messages via GADTs+category:       Data+homepage:       https://github.com/google/proto-lens#readme+bug-reports:    https://github.com/google/proto-lens/issues+author:         Judah Jacobson+maintainer:     proto-lens@googlegroups.com+copyright:      Google Inc.+license:        BSD3+license-file:   LICENSE+build-type:     Simple+cabal-version:  >= 1.10 +extra-source-files:+    Changelog.md++data-files:+    proto-lens-imports/google/protobuf/compiler/plugin.proto+    proto-lens-imports/google/protobuf/descriptor.proto++source-repository head+  type: git+  location: https://github.com/google/proto-lens+  subdir: proto-lens+ library-  hs-source-dirs: src-  exposed-modules:     Data.ProtoLens-                       Data.ProtoLens.Encoding-                       Data.ProtoLens.Message-                       Data.ProtoLens.Message.Enum-                       Data.ProtoLens.TextFormat-  other-modules:       Data.ProtoLens.Encoding.Bytes-                       Data.ProtoLens.Encoding.Wire-                       Data.ProtoLens.TextFormat.Parser-  build-depends:  attoparsec == 0.13.*-                , base >= 4.8 && < 4.11-                , bytestring == 0.10.*-                , containers == 0.5.*-                , data-default-class >= 0.0 && < 0.2-                , lens-family == 1.2.*-                , parsec == 3.1.*-                , pretty == 1.1.*-                , text == 1.2.*-                , transformers >= 0.4 && < 0.6-                , void == 0.7.*+  hs-source-dirs:+      src+  build-depends:+      attoparsec ==0.13.*+    , base >=4.8 && <4.11+    , bytestring ==0.10.*+    , containers ==0.5.*+    , data-default-class >=0.0 && <0.2+    , deepseq ==1.4.*+    , lens-family ==1.2.*+    , lens-labels ==0.2.*+    , parsec ==3.1.*+    , pretty ==1.1.*+    , text ==1.2.*+    , transformers >=0.4 && <0.6+    , void ==0.7.*+  exposed-modules:+      Data.ProtoLens+      Data.ProtoLens.Encoding+      Data.ProtoLens.Encoding.Wire+      Data.ProtoLens.Message+      Data.ProtoLens.Message.Enum+      Data.ProtoLens.Service.Types+      Data.ProtoLens.TextFormat+      Proto.Google.Protobuf.Compiler.Plugin+      Proto.Google.Protobuf.Compiler.Plugin_Fields+      Proto.Google.Protobuf.Descriptor+      Proto.Google.Protobuf.Descriptor_Fields+  other-modules:+      Data.ProtoLens.Encoding.Bytes+      Data.ProtoLens.TextFormat.Parser+  default-language: Haskell2010

@@ -12,10 +12,12 @@ {-# LANGUAGE GADTs #-} {-# LANGUAGE LambdaCase #-} {-# LANGUAGE PatternGuards #-}+{-# LANGUAGE RankNTypes #-} {-# LANGUAGE ScopedTypeVariables #-} module Data.ProtoLens.Encoding(     encodeMessage,     buildMessage,+    buildMessageDelimited,     decodeMessage,     decodeMessageOrDie,     ) where@@ -28,13 +30,14 @@ import Control.Monad (guard) import Data.Attoparsec.ByteString as Parse import Data.Bool (bool)+import Data.Monoid ((<>)) import Data.Text.Encoding (encodeUtf8, decodeUtf8') import Data.Text.Encoding.Error (UnicodeException(..)) import qualified Data.ByteString as B import qualified Data.Map.Strict as Map import Data.ByteString.Lazy.Builder as Builder import qualified Data.ByteString.Lazy as L-import Lens.Family2 (set, over, (^.), (&))+import Lens.Family2 (Lens', set, over, (^.), (&))  -- TODO: We could be more incremental when parsing/encoding length-based fields, -- rather than forcing the whole thing.  E.g., for encoding we're doing extra@@ -51,23 +54,26 @@ parseMessage end = do     (msg, unsetFields) <- loop def requiredFields     if Map.null unsetFields-        then return $ reverseRepeatedFields fields msg+        then return $ over unknownFields reverse+                    $ reverseRepeatedFields fields msg         else fail $ "Missing required fields "                         ++ show (map fieldDescriptorName                                     $ Map.elems $ unsetFields)   where-    fields = fieldsByTag descriptor+    fields = fieldsByTag+    addUnknown :: TaggedValue -> msg -> msg+    addUnknown !f = over' unknownFields (f :)     requiredFields = Map.filter isRequired fields     loop :: msg -> Map.Map Tag (FieldDescriptor msg)             -> Parser (msg, Map.Map Tag (FieldDescriptor msg))     loop msg unsetFields = ((msg, unsetFields) <$ end)                 <|> do                     tv@(TaggedValue tag _) <- getTaggedValue-                    case Map.lookup (Tag tag) fields of-                        Nothing -> loop msg unsetFields+                    case Map.lookup tag fields of+                        Nothing -> (loop $! addUnknown tv msg) unsetFields                         Just field -> do                             !msg' <- parseAndAddField msg field tv-                            loop msg' $! Map.delete (Tag tag) unsetFields+                            loop msg' $! Map.delete tag unsetFields  -- | Decode a message from its wire format.  Throws an error if the decoding -- fails.@@ -87,23 +93,28 @@     !msg     (FieldDescriptor name typeDescriptor accessor)     (TaggedValue tag (WireValue wt val)) = let-          getSimpleVal = case fieldWireType typeDescriptor of-                            GroupFieldType -> do+          getSimpleVal = case typeDescriptor of+                            MessageField GroupType -> do                                 Equal <- equalWireTypes name StartGroup wt                                 parseMessage (endOfGroup name tag)-                            FieldWireType fieldWt _ get -> do-                                Equal <- equalWireTypes name fieldWt wt-                                runEither $ get val+                            MessageField MessageType -> do+                                Equal <- equalWireTypes name Lengthy wt+                                runEither $ decodeMessage val+                            ScalarField f -> case fieldWireType f of+                                FieldWireType fieldWt _ get -> do+                                    Equal <- equalWireTypes name fieldWt wt+                                    runEither $ get val           -- Get a block of packed values, reversed.-          getPackedVals = case fieldWireType typeDescriptor of-            GroupFieldType -> fail "Groups can't be packed"-            FieldWireType fieldWt _ get -> do-              Equal <- equalWireTypes name Lengthy wt-              let getElt = do-                        wv <- getWireValue fieldWt tag-                        x <- runEither $ get wv-                        return $! x-              runEither $ parseOnly (manyReversedTill getElt endOfInput) val+          getPackedVals = case typeDescriptor of+            MessageField _ -> fail "Messages can't be packed"+            ScalarField f -> case fieldWireType f of+              FieldWireType fieldWt _ get -> do+                Equal <- equalWireTypes name Lengthy wt+                let getElt = do+                          wv <- getWireValue fieldWt+                          x <- runEither $ get wv+                          return $! x+                runEither $ parseOnly (manyReversedTill getElt endOfInput) val           in case accessor of               PlainField _ f -> do                   !x <- getSimpleVal@@ -118,12 +129,12 @@               RepeatedField _ f                 -> (do                         !x <- getSimpleVal-                        return $! over f (\(!xs) -> x:xs) msg)-                <|> (do +                        return $! over' f (x :) msg)+                <|> (do                         xs <- getPackedVals-                        return $! over f (\(!ys) -> xs++ys) msg)+                        return $! over' f (xs ++) msg)                 <|> fail ("Field " ++ name-                            ++ "expects a repeated field wire type but found "+                            ++ " expects a repeated field wire type but found "                             ++ show wt)               MapField keyLens valueLens f -> do                   entry <- getSimpleVal@@ -133,6 +144,15 @@                       (Map.insert key value)                       msg +-- | Strict version of 'over' that forces the old value.+-- Helps prevent gross space leaks when modifying a list field.+--+-- In particular, a naive `@over f (x :) y@ keeps the old value of @y@ around+-- in a thunk, because @(:)@ isn't strict in its second argument.  (Similarly+-- for @(++)@.)+over' :: Lens' a b -> (b -> b) -> a -> a+over' f g = over f (\(!x) -> g x)+ -- | Run the parser zero or more times, until the "end" parser succeeds. -- Returns a list of the parsed elements, in reverse order. manyReversedTill :: Parser a -> Parser b -> Parser [a]@@ -146,34 +166,50 @@  -- | Encode a message to the wire format, as part of a 'Builder'. buildMessage :: Message msg => msg -> Builder-buildMessage msg = foldMap putTaggedValue (messageToTaggedValues msg)+buildMessage = foldMap putTaggedValue . messageToTaggedValues +-- | Encode a message to the wire format, prefixed by its size as a VarInt,+-- as part of a 'Builder'.+--+-- This can be used to build up streams of messages in the size-delimited+-- format expected by some protocols.+buildMessageDelimited :: Message msg => msg -> Builder+buildMessageDelimited msg =+  let b = L.toStrict . toLazyByteString $ buildMessage msg in+    putVarInt (fromIntegral $ B.length b) <> byteString b+ -- | Encode a message as a sequence of key-value pairs. messageToTaggedValues :: Message msg => msg -> [TaggedValue]-messageToTaggedValues msg = mconcat-    [ messageFieldToVals t fieldDescr msg-    | (Tag t, fieldDescr) <- Map.toList (fieldsByTag descriptor)-    ]+messageToTaggedValues msg =+    mconcat+        [ messageFieldToVals tag fieldDescr msg+        | (tag, fieldDescr) <- Map.toList fieldsByTag+        ]+    ++ msg ^. unknownFields -messageFieldToVals :: Int -> FieldDescriptor a -> a -> [TaggedValue]+messageFieldToVals :: Tag -> FieldDescriptor a -> a -> [TaggedValue] messageFieldToVals tag (FieldDescriptor _ typeDescriptor accessor) msg =     let         embed src-            = case fieldWireType typeDescriptor of-                FieldWireType wt convert _-                    -> [TaggedValue tag $ WireValue wt (convert src)]-                GroupFieldType-                    -> TaggedValue tag (WireValue StartGroup ())+            = case typeDescriptor of+                MessageField MessageType -> [TaggedValue tag $ WireValue Lengthy+                                                  $ encodeMessage src]+                MessageField GroupType ->+                    TaggedValue tag (WireValue StartGroup ())                             : messageToTaggedValues src                                 ++ [TaggedValue tag $ WireValue EndGroup ()]+                ScalarField f -> case fieldWireType f of+                    FieldWireType wt convert _ ->+                        [TaggedValue tag $ WireValue wt (convert src)]         embedPacked [] = []         embedPacked src-            = case fieldWireType typeDescriptor of-                GroupFieldType -> error "GroupFieldType can't be packed"-                FieldWireType wt convert _ -> let-                    v = L.toStrict $ toLazyByteString-                        $ mconcat [putWireValue wt (convert x) | x <- src]-                    in [TaggedValue tag $ WireValue Lengthy v]+            = case typeDescriptor of+                MessageField _ -> error "Messages can't be packed"+                ScalarField f -> case fieldWireType f of+                    FieldWireType wt convert _ -> let+                        v = L.toStrict $ toLazyByteString+                            $ mconcat [putWireValue wt (convert x) | x <- src]+                        in [TaggedValue tag $ WireValue Lengthy v]     in case accessor of             PlainField d f                 -- proto3 optional scalar field:@@ -194,9 +230,8 @@ data FieldWireType value where     FieldWireType :: WireType w -> (value -> w) -> (w -> Either String value)                   -> FieldWireType value-    GroupFieldType :: Message value => FieldWireType value -fieldWireType :: FieldTypeDescriptor value -> FieldWireType value+fieldWireType :: ScalarField value -> FieldWireType value -- TODO: Don't let toEnum crash on unknown enum values. fieldWireType EnumField = simpleFieldWireType VarInt                               (fromIntegral . fromEnum)@@ -223,11 +258,8 @@ fieldWireType StringField = FieldWireType Lengthy encodeUtf8                                     (stringizeError . decodeUtf8') fieldWireType BytesField = identityFieldWireType Lengthy-fieldWireType MessageField = FieldWireType Lengthy encodeMessage-                                decodeMessage-fieldWireType GroupField = GroupFieldType -endOfGroup :: String -> Int -> Parser ()+endOfGroup :: String -> Tag -> Parser () endOfGroup name tag = do     TaggedValue tag' (WireValue wt _) <- getTaggedValue     Equal <- equalWireTypes name EndGroup wt

@@ -5,6 +5,9 @@ -- https://developers.google.com/open-source/licenses/bsd  {-# LANGUAGE GADTs #-}+{-# LANGUAGE GeneralizedNewtypeDeriving #-}+{-# LANGUAGE PatternGuards #-}+{-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE RankNTypes #-} -- | Module defining the individual base wire types (e.g. VarInt, Fixed64) and -- how to encode/decode them.@@ -12,6 +15,7 @@     WireType(..),     SomeWireType(..),     WireValue(..),+    Tag(..),     TaggedValue(..),     getTaggedValue,     putTaggedValue,@@ -19,8 +23,10 @@     putWireValue,     Equal(..),     equalWireTypes,+    decodeFieldSet,     ) where +import Control.DeepSeq (NFData(..)) import Data.Attoparsec.ByteString as Parse import Data.Bits import qualified Data.ByteString as B@@ -31,6 +37,9 @@ import Data.ProtoLens.Encoding.Bytes  data WireType a where+    -- Note: all of these types are fully strict (vs, say,+    -- Data.ByteString.Lazy.ByteString).  If that changes, we'll+    -- need to update the NFData instance.     VarInt :: WireType Word64     Fixed64 :: WireType Word64     Fixed32 :: WireType Word32@@ -38,16 +47,42 @@     StartGroup :: WireType ()     EndGroup :: WireType () +instance Show (WireType a) where+    show = show . wireTypeToInt++ -- A value read from the wire data WireValue = forall a . WireValue !(WireType a) !a++instance Show WireValue where+    show (WireValue VarInt x) = show x+    show (WireValue Fixed64 x) = show x+    show (WireValue Fixed32 x) = show x+    show (WireValue Lengthy x) = show x+    show (WireValue StartGroup x) = show x+    show (WireValue EndGroup x) = show x++ -- The wire contents of a single key-value pair in a Message.-data TaggedValue = TaggedValue !Int !WireValue+data TaggedValue = TaggedValue !Tag !WireValue+    deriving (Show, Eq, Ord) -instance Show (WireType a) where-    show = show . wireTypeToInt+-- TaggedValue, WireValue and Tag are strict, so their NFData instances are+-- trivial:+instance NFData TaggedValue where+    rnf = (`seq` ()) +instance NFData WireValue where+    rnf = (`seq` ())++-- | A tag that identifies a particular field of the message when converting+-- to/from the wire format.+newtype Tag = Tag { unTag :: Int}+    deriving (Show, Eq, Ord, Num, NFData)+ data Equal a b where-    Equal :: Equal a a+    -- TODO: move Eq/Ord instance somewhere else?+    Equal :: (Eq a, Ord a) => Equal a a  -- Assert that two wire types are the same, or fail with a message about this -- field.@@ -64,14 +99,26 @@     = fail $ "Field " ++ name ++ " expects wire type " ++ show expected         ++ " but found " ++ show actual -getWireValue :: WireType a -> Int -> Parser a-getWireValue VarInt _ = getVarInt-getWireValue Fixed64 _ = anyBits-getWireValue Fixed32 _ = anyBits-getWireValue Lengthy _ = getVarInt >>= Parse.take . fromIntegral-getWireValue StartGroup _ = return ()-getWireValue EndGroup _ = return ()+instance Eq WireValue where+    WireValue t v == WireValue t' v'+        | Just Equal <- equalWireTypes "" t t'+            = v == v'+        | otherwise = False +instance Ord WireValue where+    WireValue t v `compare` WireValue t' v'+        | Just Equal <- equalWireTypes "" t t'+            = v `compare` v'+        | otherwise = wireTypeToInt t `compare` wireTypeToInt t'++getWireValue :: WireType a -> Parser a+getWireValue VarInt = getVarInt+getWireValue Fixed64 = anyBits+getWireValue Fixed32 = anyBits+getWireValue Lengthy = getVarInt >>= Parse.take . fromIntegral+getWireValue StartGroup = return ()+getWireValue EndGroup = return ()+ putWireValue :: WireType a -> a -> Builder putWireValue VarInt n = putVarInt n putWireValue Fixed64 n = word64LE n@@ -100,11 +147,11 @@ intToWireType 5 = Right $ SomeWireType Fixed32 intToWireType n = Left $ "Unrecognized wire type " ++ show n -putTypeAndTag :: WireType a -> Int -> Builder-putTypeAndTag wt tag+putTypeAndTag :: WireType a -> Tag -> Builder+putTypeAndTag wt (Tag tag)     = putVarInt $ wireTypeToInt wt .|. fromIntegral tag `shiftL` 3 -getTypeAndTag :: Parser (SomeWireType, Int)+getTypeAndTag :: Parser (SomeWireType, Tag) getTypeAndTag = do   n <- getVarInt   case intToWireType (n .&. 7) of@@ -114,9 +161,12 @@ getTaggedValue :: Parser TaggedValue getTaggedValue = do     (SomeWireType wt, tag) <- getTypeAndTag-    val <- getWireValue wt tag+    val <- getWireValue wt     return $ TaggedValue tag (WireValue wt val)  putTaggedValue :: TaggedValue -> Builder putTaggedValue (TaggedValue tag (WireValue wt val)) =     putTypeAndTag wt tag <> putWireValue wt val++decodeFieldSet :: B.ByteString -> Either String [TaggedValue]+decodeFieldSet = parseOnly (manyTill getTaggedValue endOfInput)

@@ -6,14 +6,18 @@  {-# LANGUAGE GADTs #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-}+{-# LANGUAGE OverloadedStrings #-}+{-# LANGUAGE PatternGuards #-} {-# LANGUAGE RankNTypes #-}+{-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE StandaloneDeriving #-}+{-# LANGUAGE TypeApplications #-} -- | Datatypes for reflection of protocol buffer messages. module Data.ProtoLens.Message (     -- * Reflection of Messages     Message(..),     Tag(..),-    MessageDescriptor(..),+    allFields,     FieldDescriptor(..),     fieldDescriptorName,     isRequired,@@ -21,15 +25,29 @@     WireDefault(..),     Packing(..),     FieldTypeDescriptor(..),+    ScalarField(..),+    MessageOrGroup(..),     FieldDefault(..),     MessageEnum(..),     -- * Building protocol buffers     Default(..),     build,+    -- * Proto registries+    Registry,+    register,+    lookupRegistered,+    SomeMessageType(..),+    -- * Any messages+    matchAnyMessage,+    AnyMessageDescriptor(..),     -- * Utilities for constructing protocol buffer lenses     maybeLens,     -- * Internal utilities for parsing protocol buffers     reverseRepeatedFields,+    -- * Unknown fields+    FieldSet,+    TaggedValue(..),+    discardUnknownFields,     ) where  import qualified Data.ByteString as B@@ -38,37 +56,41 @@ import qualified Data.Map as Map import Data.Map (Map) import Data.Maybe (fromMaybe)+import Data.Proxy (Proxy(..)) import qualified Data.Text as T import Data.Word-import Lens.Family2 (Lens', over)+import Lens.Family2 (Lens', over, set) import Lens.Family2.Unchecked (lens) +import Data.ProtoLens.Encoding.Wire+    ( Tag(..)+    , TaggedValue(..)+    )+ -- | Every protocol buffer is an instance of 'Message'.  This class enables -- serialization by providing reflection of all of the fields that may be used -- by this type. class Default msg => Message msg where-    descriptor :: MessageDescriptor msg---- | The description of a particular protocol buffer message type.-data MessageDescriptor msg = MessageDescriptor-    {  messageName :: T.Text-      -- ^ A unique identifier for this type, of the format-      -- @"packagename.messagename"@.-    , fieldsByTag :: Map Tag (FieldDescriptor msg)-      -- ^ The fields of the proto, indexed by their (integer) tag.-    , fieldsByTextFormatName :: Map String (FieldDescriptor msg)-      -- ^ This map is keyed by the name of the field used for text format protos.-      -- This is just the field name for every field except for group fields,-      -- which use their Message type name in text protos instead of their-      -- field name. For example, "optional group Foo" has the field name "foo"-      -- but in this map it is stored with the key "Foo".-    }+    -- | A unique identifier for this type, of the format+    -- @"packagename.messagename"@.+    messageName :: Proxy msg -> T.Text+    -- | The fields of the proto, indexed by their (integer) tag.+    fieldsByTag :: Map Tag (FieldDescriptor msg)+    -- | This map is keyed by the name of the field used for text format protos.+    -- This is just the field name for every field except for group fields,+    -- which use their Message type name in text protos instead of their+    -- field name. For example, "optional group Foo" has the field name "foo"+    -- but in this map it is stored with the key "Foo".+    fieldsByTextFormatName :: Map String (FieldDescriptor msg)+    fieldsByTextFormatName =+        Map.fromList [(n, f) | f@(FieldDescriptor n _ _) <- allFields]+    -- | Access the unknown fields of a Message.+    unknownFields :: Lens' msg FieldSet --- | A tag that identifies a particular field of the message when converting--- to/from the wire format.-newtype Tag = Tag { unTag :: Int}-    deriving (Show, Eq, Ord, Num)+allFields :: Message msg => [FieldDescriptor msg]+allFields = Map.elems fieldsByTag +type FieldSet = [TaggedValue]  -- | A description of a specific field of a protocol buffer. --@@ -157,33 +179,57 @@  -- | A description of the type of a given field value. data FieldTypeDescriptor value where-    MessageField :: Message value => FieldTypeDescriptor value-    GroupField :: Message value => FieldTypeDescriptor value-    EnumField :: MessageEnum value => FieldTypeDescriptor value-    Int32Field :: FieldTypeDescriptor Int32-    Int64Field :: FieldTypeDescriptor Int64-    UInt32Field :: FieldTypeDescriptor Word32-    UInt64Field :: FieldTypeDescriptor Word64-    SInt32Field :: FieldTypeDescriptor Int32-    SInt64Field :: FieldTypeDescriptor Int64-    Fixed32Field :: FieldTypeDescriptor Word32-    Fixed64Field :: FieldTypeDescriptor Word64-    SFixed32Field :: FieldTypeDescriptor Int32-    SFixed64Field :: FieldTypeDescriptor Int64-    FloatField :: FieldTypeDescriptor Float-    DoubleField :: FieldTypeDescriptor Double-    BoolField :: FieldTypeDescriptor Bool-    StringField :: FieldTypeDescriptor T.Text-    BytesField :: FieldTypeDescriptor B.ByteString+    MessageField :: Message value => MessageOrGroup -> FieldTypeDescriptor value+    ScalarField :: ScalarField value -> FieldTypeDescriptor value  deriving instance Show (FieldTypeDescriptor value) +data MessageOrGroup = MessageType | GroupType+    deriving Show++data ScalarField t where+    EnumField :: MessageEnum value => ScalarField value+    Int32Field :: ScalarField Int32+    Int64Field :: ScalarField Int64+    UInt32Field :: ScalarField Word32+    UInt64Field :: ScalarField Word64+    SInt32Field :: ScalarField Int32+    SInt64Field :: ScalarField Int64+    Fixed32Field :: ScalarField Word32+    Fixed64Field :: ScalarField Word64+    SFixed32Field :: ScalarField Int32+    SFixed64Field :: ScalarField Int64+    FloatField :: ScalarField Float+    DoubleField :: ScalarField Double+    BoolField :: ScalarField Bool+    StringField :: ScalarField T.Text+    BytesField :: ScalarField B.ByteString++deriving instance Show (ScalarField value)++matchAnyMessage :: forall value . FieldTypeDescriptor value -> Maybe (AnyMessageDescriptor value)+matchAnyMessage (MessageField _)+    | messageName (Proxy @value) == "google.protobuf.Any"+    , Just (FieldDescriptor _ (ScalarField StringField) (PlainField Optional typeUrlLens))+        <- Map.lookup 1 (fieldsByTag @value)+    , Just (FieldDescriptor _ (ScalarField BytesField) (PlainField Optional valueLens))+        <- Map.lookup 2 (fieldsByTag @value)+        = Just $ AnyMessageDescriptor typeUrlLens valueLens+matchAnyMessage _ = Nothing++data AnyMessageDescriptor msg+    = AnyMessageDescriptor+        { anyTypeUrlLens :: Lens' msg T.Text+        , anyValueLens :: Lens' msg B.ByteString+        }+ -- | A class for protocol buffer enums that enables safe decoding. class (Enum a, Bounded a) => MessageEnum a where     -- | Convert the given 'Int' to an enum value.  Returns 'Nothing' if     -- no corresponding value was defined in the .proto file.     maybeToEnum :: Int -> Maybe a-    -- | Get the name of this enum as defined in the .proto file.+    -- | Get the name of this enum as defined in the .proto file.  Used+    -- for the human-readable output in @Data.ProtoLens.TextFormat@.     showEnum :: a -> String     -- | Convert the given 'String' to an enum value. Returns 'Nothing' if     -- no corresponding value was defined in the .proto file.@@ -231,3 +277,32 @@     reverseListField x (FieldDescriptor _ _ (RepeatedField _ f))         = over f reverse x     reverseListField x _ = x++-- | A set of known message types. Can help encode/decode protobufs containing+-- @Data.ProtoLens.Any@ values in a more human-readable text format.+--+-- Registries can be combined using their 'Monoid' instance.+--+-- See the @withRegistry@ functions in 'Data.ProtoLens.TextFormat'+newtype Registry = Registry (Map.Map T.Text SomeMessageType)+    deriving Monoid++-- | Build a 'Registry' containing a single proto type.+--+--   Example:+-- > register (Proxy :: Proxy Proto.My.Proto.Type)+register :: forall msg . Message msg => Proxy msg -> Registry+register p = Registry $ Map.singleton (messageName (Proxy @msg)) (SomeMessageType p)++-- | Look up a message type by name (e.g.,+-- @"type.googleapis.com/google.protobuf.FloatValue"@). The URL corresponds to+-- the field @google.protobuf.Any.type_url@.+lookupRegistered :: T.Text -> Registry -> Maybe SomeMessageType+lookupRegistered n (Registry m) = Map.lookup (snd $ T.breakOnEnd "/" n) m++data SomeMessageType where+    SomeMessageType :: Message msg => Proxy msg -> SomeMessageType++-- TODO: recursively+discardUnknownFields :: Message msg => msg -> msg+discardUnknownFields = set unknownFields []

@@ -0,0 +1,126 @@+{-# LANGUAGE ConstraintKinds       #-}+{-# LANGUAGE DataKinds             #-}+{-# LANGUAGE FlexibleContexts      #-}+{-# LANGUAGE FlexibleInstances     #-}+{-# LANGUAGE GADTs                 #-}+{-# LANGUAGE KindSignatures        #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE PolyKinds             #-}+{-# LANGUAGE RankNTypes            #-}+{-# LANGUAGE TypeFamilies          #-}+{-# LANGUAGE TypeOperators         #-}+{-# LANGUAGE UndecidableInstances  #-}+{-# OPTIONS_GHC -fno-warn-redundant-constraints #-}++-- | This module provides typeclasses for describing protobuf service metadata.+-- It is intended to be used by library authors to generating bindings against+-- proto services for specific RPC backends.+module Data.ProtoLens.Service.Types+  ( Service (..)+  , HasAllMethods+  , HasMethodImpl (..)+  , HasMethod+  , StreamingType (..)+  ) where++import Data.Kind (Constraint)+import Data.ProtoLens.Message (Message)+import GHC.TypeLits+++-- | Reifies the fact that there is a 'HasMethod' instance for every symbol+-- claimed by the 'ServiceMethods' associated type.+class HasAllMethods s (ms :: [Symbol])+instance HasAllMethods s '[]+instance (HasAllMethods s ms, HasMethodImpl s m) => HasAllMethods s (m ': ms)+++-- | Metadata describing a protobuf service. The 's' parameter is a phantom+-- type generated by proto-lens.+--+-- The 'ServiceName' and 'ServicePackage' associated type can be used to+-- generate RPC endpoint paths.+--+-- 'ServiceMethods' is a promoted list containing every method defined on the+-- service. As witnessed by the 'HasAllMethods' superclass constraint here,+-- this type can be used to discover every instance of 'HasMethod' available+-- for the service.+class ( KnownSymbol (ServiceName s)+      , KnownSymbol (ServicePackage s)+      , HasAllMethods s (ServiceMethods s)+      ) => Service s where+  type ServiceName s    :: Symbol+  type ServicePackage s :: Symbol+  type ServiceMethods s :: [Symbol]+++------------------------------------------------------------------------------+-- | Data type to be used as a promoted type for 'MethodStreamingType'.+data StreamingType+  = NonStreaming+  | ClientStreaming+  | ServerStreaming+  | BiDiStreaming+  deriving (Eq, Ord, Enum, Bounded, Read, Show)+++-- | Metadata describing a service method. The 'MethodInput' and 'MethodOutput'+-- type families correspond to the 'Message's generated by proto-lens for the+-- RPC as described in the protobuf.+--+-- 'IsClientStreaming' and 'IsServerStreaming' can be used to dispatch on+-- library code which wishes to provide different interfaces depending on the+-- type of streaming of the method.+--+-- Library code should use 'HasMethod' instead of this class directly whenever+-- the constraint will be exposed to the end user. 'HasMethod' provides+-- substantially friendlier error messages when used incorrectly.+class ( KnownSymbol m+      , KnownSymbol (MethodName s m)+      , Service s+      , Message (MethodInput  s m)+      , Message (MethodOutput s m)+      ) => HasMethodImpl s (m :: Symbol) where+  type MethodName          s m :: Symbol+  type MethodInput         s m :: *+  type MethodOutput        s m :: *+  type MethodStreamingType s m :: StreamingType+++-- | Helper constraint that expands to a user-friendly error message when 'm'+-- isn't actually a method provided by service 's'.+type HasMethod s m =+  ( RequireHasMethod s m (ListContains m (ServiceMethods s))+  , HasMethodImpl s m+  )+++-- | Outputs an error message saying that the given method wasn't found, and+-- suggests alternatives the user might have wanted.+type family RequireHasMethod s (m :: Symbol) (h :: Bool) :: Constraint where+  RequireHasMethod s m 'False = TypeError+       ( 'Text "No method "+   ':<>: 'ShowType m+   ':<>: 'Text " available for service '"+   ':<>: 'ShowType s+   ':<>: 'Text "'."+   ':$$: 'Text "Available methods are: "+   ':<>: ShowList (ServiceMethods s)+       )+  RequireHasMethod s m 'True = ()+++-- | Expands to 'True' when 'n' is in promoted list 'hs', 'False' otherwise.+type family ListContains (n :: k) (hs :: [k]) :: Bool where+  ListContains n '[]       = 'False+  ListContains n (n ': hs) = 'True+  ListContains n (x ': hs) = ListContains n hs+++-- | Pretty prints a promoted list.+type family ShowList (ls :: [k]) :: ErrorMessage where+  ShowList '[]  = 'Text ""+  ShowList '[x] = 'ShowType x+  ShowList (x ': xs) =+    'ShowType x ':<>: 'Text ", " ':<>: ShowList xs+

@@ -6,31 +6,41 @@  -- | Functions for converting protocol buffers to a human-readable text format. {-# LANGUAGE GADTs #-}+{-# LANGUAGE NamedFieldPuns #-} {-# LANGUAGE PatternGuards #-} {-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE TypeApplications #-}  module Data.ProtoLens.TextFormat(     showMessage,+    showMessageWithRegistry,     showMessageShort,     pprintMessage,+    pprintMessageWithRegistry,     readMessage,+    readMessageWithRegistry,     readMessageOrDie,     ) where -import Lens.Family2 ((&),(^.),(.~), set, over)+import Lens.Family2 ((&),(^.),(.~), set, over, view) import Control.Arrow (left)+import Data.Bifunctor (first) import qualified Data.ByteString import Data.Char (isPrint, isAscii, chr) import Data.Foldable (foldlM, foldl')-import Data.Maybe (catMaybes) import qualified Data.Map as Map+import Data.Maybe (catMaybes)+import Data.Proxy (Proxy(Proxy))+import Data.ProtoLens.Encoding (encodeMessage, decodeMessage) import qualified Data.Set as Set import qualified Data.Text.Encoding as Text import qualified Data.Text.Lazy as Lazy+import qualified Data.Text as Text (unpack) import Numeric (showOct) import Text.Parsec (parse) import Text.PrettyPrint +import Data.ProtoLens.Encoding.Wire import Data.ProtoLens.Message import qualified Data.ProtoLens.TextFormat.Parser as Parser @@ -52,28 +62,36 @@  -- | Pretty-print the given message into a human-readable form. pprintMessage :: Message msg => msg -> Doc-pprintMessage = pprintMessage' descriptor+pprintMessage = pprintMessageWithRegistry mempty +-- | Pretty-print the given message into human-readable form, using the given+-- 'Registry' to decode @google.protobuf.Any@ values.+pprintMessageWithRegistry :: Message msg => Registry -> msg -> Doc+pprintMessageWithRegistry reg msg+    -- Either put all fields together on a single line, or use a separate line+    -- for each field.  We use a single "sep" for all fields (and all elements+    -- of all the repeated fields) to avoid putting some repeated fields on one+    -- line and other fields on multiple lines, which is less readable.+    = sep $ concatMap (pprintField reg msg) allFields+              ++ map pprintTaggedValue (msg ^. unknownFields)+ -- | Convert the given message into a human-readable 'String'. showMessage :: Message msg => msg -> String showMessage = render . pprintMessage +-- | Convert the given message into a human-readable 'String', using the+-- 'Registry' to encode @google.protobuf.Any@ values.+showMessageWithRegistry :: Message msg => Registry -> msg -> String+showMessageWithRegistry reg = render . pprintMessageWithRegistry reg+ -- | Serializes a proto as a string on a single line.  Useful for debugging -- and error messages like @.DebugString()@ in other languages. showMessageShort :: Message msg => msg -> String showMessageShort = renderStyle (Style OneLineMode maxBound 1.5) . pprintMessage -pprintMessage' :: MessageDescriptor msg -> msg -> Doc-pprintMessage' descr msg-    -- Either put all fields together on a single line, or use a separate line-    -- for each field.  We use a single "sep" for all fields (and all elements-    -- of all the repeated fields) to avoid putting some repeated fields on one-    -- line and other fields on multiple lines, which is less readable.-    = sep $ concatMap (pprintField msg) $ Map.elems $ fieldsByTag descr--pprintField :: msg -> FieldDescriptor msg -> [Doc]-pprintField msg (FieldDescriptor name typeDescr accessor)-    = map (pprintFieldValue name typeDescr) $ case accessor of+pprintField :: Registry -> msg -> FieldDescriptor msg -> [Doc]+pprintField reg msg (FieldDescriptor name typeDescr accessor)+    = map (pprintFieldValue reg name typeDescr) $ case accessor of         PlainField d f             | Optional <- d, val == fieldDefault -> []             | otherwise -> [val]@@ -85,28 +103,50 @@           where pairToMsg (x,y) = def & k .~ x                                       & v .~ y -pprintFieldValue :: String -> FieldTypeDescriptor value -> value -> Doc-pprintFieldValue name MessageField m-    = sep [text name <+> lbrace, nest 2 (pprintMessage m), rbrace]-pprintFieldValue name EnumField x = text name <> colon <+> text (showEnum x)-pprintFieldValue name Int32Field x = primField name x-pprintFieldValue name Int64Field x = primField name x-pprintFieldValue name UInt32Field x = primField name x-pprintFieldValue name UInt64Field x = primField name x-pprintFieldValue name SInt32Field x = primField name x-pprintFieldValue name SInt64Field x = primField name x-pprintFieldValue name Fixed32Field x = primField name x-pprintFieldValue name Fixed64Field x = primField name x-pprintFieldValue name SFixed32Field x = primField name x-pprintFieldValue name SFixed64Field x = primField name x-pprintFieldValue name FloatField x = primField name x-pprintFieldValue name DoubleField x = primField name x-pprintFieldValue name BoolField x = text name <> colon <+> boolValue x-pprintFieldValue name StringField x = pprintByteString name (Text.encodeUtf8 x)-pprintFieldValue name BytesField x = pprintByteString name x-pprintFieldValue name GroupField m-    = text name <+> lbrace $$ nest 2 (pprintMessage m) $$ rbrace+pprintFieldValue :: Registry -> String -> FieldTypeDescriptor value -> value -> Doc+pprintFieldValue reg name field@(MessageField MessageType) m+  | Just AnyMessageDescriptor { anyTypeUrlLens, anyValueLens } <- matchAnyMessage field,+    typeUri <- view anyTypeUrlLens m,+    fieldData <- view anyValueLens m,+    Just (SomeMessageType (Proxy :: Proxy value')) <- lookupRegistered typeUri reg,+    Right (anyValue :: value') <- decodeMessage fieldData =+      pprintSubmessage name+          $ sep+            [ lbrack <> text (Text.unpack typeUri) <> rbrack <+> lbrace+            , nest 2 (pprintMessageWithRegistry reg anyValue)+            , rbrace ]+  | otherwise =+      pprintSubmessage name (pprintMessageWithRegistry reg m)+pprintFieldValue reg name (MessageField GroupType) m+    = pprintSubmessage name (pprintMessageWithRegistry reg m)+pprintFieldValue _ name (ScalarField f) x = named name $ pprintScalarValue f x +named :: String -> Doc -> Doc+named n x = text n <> colon <+> x+++pprintScalarValue :: ScalarField value -> value -> Doc+pprintScalarValue EnumField x = text (showEnum x)+pprintScalarValue Int32Field x = primField x+pprintScalarValue Int64Field x = primField x+pprintScalarValue UInt32Field x = primField x+pprintScalarValue UInt64Field x = primField x+pprintScalarValue SInt32Field x = primField x+pprintScalarValue SInt64Field x = primField x+pprintScalarValue Fixed32Field x = primField x+pprintScalarValue Fixed64Field x = primField x+pprintScalarValue SFixed32Field x = primField x+pprintScalarValue SFixed64Field x = primField x+pprintScalarValue FloatField x = primField x+pprintScalarValue DoubleField x = primField x+pprintScalarValue BoolField x = boolValue x+pprintScalarValue StringField x = pprintByteString (Text.encodeUtf8 x)+pprintScalarValue BytesField x = pprintByteString x++pprintSubmessage :: String -> Doc -> Doc+pprintSubmessage name contents =+    sep [text name <+> lbrace, nest 2 contents, rbrace]+ -- | Formats a string in a way that mostly matches the C-compatible escaping -- used by the Protocol Buffer distribution.  We depart a bit by escaping all -- non-ASCII characters, which depending on the locale, the distribution might@@ -116,8 +156,8 @@ -- and \\ only.  Note that Haskell string-literal syntax calls for "\011" to be -- interpreted as decimal 11, rather than the decimal 9 it actually represent, -- so you can't use Prelude.read to parse the strings created here.-pprintByteString :: String -> Data.ByteString.ByteString -> Doc-pprintByteString name x = text name <> colon <+> char '\"'+pprintByteString :: Data.ByteString.ByteString -> Doc+pprintByteString x = char '\"'     <> text (concatMap escape $ Data.ByteString.unpack x) <> char '\"'   where escape w8 | ch == '\n'               = "\\n"                   | ch == '\r'               = "\\r"@@ -131,19 +171,34 @@             ch = chr $ fromIntegral w8             pad str = replicate (3 - length str) '0' ++ str -primField :: Show value => String -> value -> Doc-primField name x = text name <> colon <+> text (show x)+primField :: Show value => value -> Doc+primField x = text (show x)  boolValue :: Bool -> Doc boolValue True = text "true" boolValue False = text "false" +pprintTaggedValue :: TaggedValue -> Doc+pprintTaggedValue (TaggedValue t (WireValue v x)) = case v of+    VarInt -> named name $ primField x+    Fixed64 -> named name $ primField x+    Fixed32 -> named name $ primField x+    Lengthy -> case decodeFieldSet x of+                  Left _ -> named name $ pprintByteString x+                  Right ts -> pprintSubmessage name+                                $ sep $ map pprintTaggedValue ts+    -- TODO: implement better printing for unknown groups+    StartGroup -> named name $ text "start_group"+    EndGroup -> named name $ text "end_group"+  where+    name = show (unTag t)+ -------------------------------------------------------------------------------- -- Parsing  -- | Parse a 'Message' from the human-readable protocol buffer text format. readMessage :: Message msg => Lazy.Text -> Either String msg-readMessage str = left show (parse Parser.parser "" str) >>= buildMessage+readMessage = readMessageWithRegistry mempty  -- | Parse a 'Message' from the human-readable protocol buffer text format. -- Throws an error if the parse was not successful.@@ -152,47 +207,49 @@     Left e -> error $ "readMessageOrDie: " ++ e     Right x -> x -buildMessage :: forall msg . Message msg => Parser.Message -> Either String msg-buildMessage fields-    | missing <- missingFields desc fields, not $ null missing+-- | Parse a 'Message' from a human-readable protocol buffer text format, using+-- the given 'Registry' to decode 'Any' fields+readMessageWithRegistry :: Message msg => Registry -> Lazy.Text -> Either String msg+readMessageWithRegistry reg str = left show (parse Parser.parser "" str) >>= buildMessage reg++buildMessage :: forall msg . Message msg => Registry -> Parser.Message -> Either String msg+buildMessage reg fields+    | missing <- missingFields (Proxy @msg) fields, not $ null missing         = Left $ "Missing fields " ++ show missing-    | otherwise = reverseRepeatedFields (fieldsByTag desc)-                      <$> buildMessageFromDescriptor desc def fields-  where-    desc :: MessageDescriptor msg-    desc = descriptor+    | otherwise = reverseRepeatedFields fieldsByTag+                      <$> buildMessageFromDescriptor reg def fields -missingFields :: MessageDescriptor msg -> Parser.Message -> [String]-missingFields desc = Set.toList . foldl' deleteField requiredFieldNames+missingFields :: forall msg . Message msg => Proxy msg -> Parser.Message -> [String]+missingFields _ = Set.toList . foldl' deleteField requiredFieldNames   where     requiredFieldNames :: Set.Set String     requiredFieldNames = Set.fromList $ Map.keys                             $ Map.filter isRequired-                            $ fieldsByTextFormatName desc+                            $ fieldsByTextFormatName @msg     deleteField :: Set.Set String -> Parser.Field -> Set.Set String     deleteField fs (Parser.Field (Parser.Key name) _) = Set.delete name fs     deleteField fs (Parser.Field (Parser.UnknownKey n) _)-        | Just d <- Map.lookup (Tag (fromIntegral n)) $ fieldsByTag desc+        | Just d <- Map.lookup (Tag (fromIntegral n)) (fieldsByTag @msg)         = Set.delete (fieldDescriptorName d) fs     deleteField fs _ = fs   buildMessageFromDescriptor-    :: MessageDescriptor msg -> msg -> Parser.Message -> Either String msg-buildMessageFromDescriptor descr = foldlM (addField descr)+    :: Message msg => Registry -> msg -> Parser.Message -> Either String msg+buildMessageFromDescriptor reg = foldlM (addField reg) -addField :: MessageDescriptor msg -> msg -> Parser.Field -> Either String msg-addField descr msg (Parser.Field key rawValue) = do-    FieldDescriptor _ typeDescriptor accessor <- getFieldDescriptor-    value <- makeValue typeDescriptor rawValue+addField :: forall msg . Message msg => Registry -> msg -> Parser.Field -> Either String msg+addField reg msg (Parser.Field key rawValue) = do+    FieldDescriptor name typeDescriptor accessor <- getFieldDescriptor+    value <- makeValue name reg typeDescriptor rawValue     return $ modifyField accessor value msg   where     getFieldDescriptor         | Parser.Key name <- key, Just f <- Map.lookup name-                                                (fieldsByTextFormatName descr)+                                                fieldsByTextFormatName             = return f         | Parser.UnknownKey tag <- key, Just f <- Map.lookup (fromIntegral tag)-                                                      (fieldsByTag descr)+                                                      fieldsByTag             = return f         | otherwise = Left $ "Unrecognized field " ++ show key @@ -203,37 +260,63 @@ modifyField (MapField key value f) mapElem     = over f (Map.insert (mapElem ^. key) (mapElem ^. value)) -makeValue :: FieldTypeDescriptor value -> Parser.Value -> Either String value-makeValue Int32Field (Parser.IntValue x) = Right (fromInteger x)-makeValue Int64Field (Parser.IntValue x) = Right (fromInteger x)-makeValue UInt32Field (Parser.IntValue x) = Right (fromInteger x)-makeValue UInt64Field (Parser.IntValue x) = Right (fromInteger x)-makeValue SInt32Field (Parser.IntValue x) = Right (fromInteger x)-makeValue SInt64Field (Parser.IntValue x) = Right (fromInteger x)-makeValue Fixed32Field (Parser.IntValue x) = Right (fromInteger x)-makeValue Fixed64Field (Parser.IntValue x) = Right (fromInteger x)-makeValue SFixed32Field (Parser.IntValue x) = Right (fromInteger x)-makeValue SFixed64Field (Parser.IntValue x) = Right (fromInteger x)-makeValue FloatField (Parser.IntValue x) = Right (fromInteger x)-makeValue DoubleField (Parser.IntValue x) = Right (fromInteger x)-makeValue BoolField (Parser.IntValue x)+makeValue+    :: forall value+     . String -- ^ name of field+    -> Registry+    -> FieldTypeDescriptor value+    -> Parser.Value+    -> Either String value+makeValue name _ (ScalarField f) v =+    first (("Error parsing field " ++ show name ++ ": ") ++) $ makeScalarValue f v+makeValue name reg field@(MessageField MessageType) (Parser.MessageValue (Just typeUri) x)+    | Just AnyMessageDescriptor { anyTypeUrlLens, anyValueLens } <- matchAnyMessage field =+        case lookupRegistered typeUri reg of+          Nothing -> Left $ "Could not decode google.protobuf.Any for field "+                                ++ show name ++ ": unregistered type URI "+                                ++ show typeUri+          Just (SomeMessageType (Proxy :: Proxy value')) ->+            case buildMessage reg x :: Either String value' of+              Left err -> Left err+              Right value' -> Right (def & anyTypeUrlLens .~ typeUri+                                         & anyValueLens .~ encodeMessage value')+    | otherwise = Left ("Type mismatch parsing explicitly typed message. Expected " +++                        show (messageName (Proxy @value))  +++                        ", got " ++ show typeUri)+makeValue _ reg (MessageField _) (Parser.MessageValue _ x) = buildMessage reg x+makeValue name _ (MessageField _) val =+    Left $ "Type mismatch for field " ++ show name +++            ": expected message, found " ++ show val++makeScalarValue :: ScalarField value -> Parser.Value -> Either String value+makeScalarValue Int32Field (Parser.IntValue x) = Right (fromInteger x)+makeScalarValue Int64Field (Parser.IntValue x) = Right (fromInteger x)+makeScalarValue UInt32Field (Parser.IntValue x) = Right (fromInteger x)+makeScalarValue UInt64Field (Parser.IntValue x) = Right (fromInteger x)+makeScalarValue SInt32Field (Parser.IntValue x) = Right (fromInteger x)+makeScalarValue SInt64Field (Parser.IntValue x) = Right (fromInteger x)+makeScalarValue Fixed32Field (Parser.IntValue x) = Right (fromInteger x)+makeScalarValue Fixed64Field (Parser.IntValue x) = Right (fromInteger x)+makeScalarValue SFixed32Field (Parser.IntValue x) = Right (fromInteger x)+makeScalarValue SFixed64Field (Parser.IntValue x) = Right (fromInteger x)+makeScalarValue FloatField (Parser.IntValue x) = Right (fromInteger x)+makeScalarValue DoubleField (Parser.IntValue x) = Right (fromInteger x)+makeScalarValue BoolField (Parser.IntValue x)     | x == 0 = Right False     | x == 1 = Right True     | otherwise = Left $ "Unrecognized bool value " ++ show x-makeValue DoubleField (Parser.DoubleValue x) = Right x-makeValue FloatField (Parser.DoubleValue x) = Right (realToFrac x)-makeValue BoolField (Parser.EnumValue x)+makeScalarValue DoubleField (Parser.DoubleValue x) = Right x+makeScalarValue FloatField (Parser.DoubleValue x) = Right (realToFrac x)+makeScalarValue BoolField (Parser.EnumValue x)     | x == "true" = Right True     | x == "false" = Right False     | otherwise = Left $ "Unrecognized bool value " ++ show x-makeValue StringField (Parser.ByteStringValue x) = Right (Text.decodeUtf8 x)-makeValue BytesField (Parser.ByteStringValue x) = Right x-makeValue EnumField (Parser.IntValue x) =+makeScalarValue StringField (Parser.ByteStringValue x) = Right (Text.decodeUtf8 x)+makeScalarValue BytesField (Parser.ByteStringValue x) = Right x+makeScalarValue EnumField (Parser.IntValue x) =     maybe (Left $ "Unrecognized enum value " ++ show x) Right         (maybeToEnum $ fromInteger x)-makeValue EnumField (Parser.EnumValue x) =+makeScalarValue EnumField (Parser.EnumValue x) =     maybe (Left $ "Unrecognized enum value " ++ show x) Right         (readEnum x)-makeValue MessageField (Parser.MessageValue x) = buildMessage x-makeValue GroupField (Parser.MessageValue x) = buildMessage x-makeValue f val = Left $ "Type mismatch parsing text format: " ++ show (f, val)+makeScalarValue f val = Left $ "Type mismatch: " ++ show (f, val)

@@ -15,13 +15,15 @@     ) where  import Data.ByteString (ByteString, pack)-import Data.Char (ord)+import Data.Char (ord, isSpace) import Data.Functor.Identity (Identity) import Data.List (intercalate) import Data.Maybe (catMaybes) import Data.Text.Lazy (Text)+import qualified Data.Text as StrictText import Data.Word (Word8) import Numeric (readOct, readHex)+import Text.Parsec ((<?>)) import Text.Parsec.Char   (alphaNum, char, hexDigit, letter, octDigit, oneOf, satisfy) import Text.Parsec.Text.Lazy (Parser)@@ -67,13 +69,14 @@ data Value = IntValue Integer  -- ^ An integer   | DoubleValue Double  -- ^ Any floating point number   | ByteStringValue ByteString    -- ^ A string or bytes literal-  | MessageValue Message  -- ^ A sub message+  | MessageValue (Maybe StrictText.Text) Message  -- ^ A sub message, with an optional type URI   | EnumValue String  -- ^ Any undelimited string (including false & true)   deriving (Show,Ord,Eq)  instance Show Key   where-    show (Key name) = name+    show (Key name) = show name  -- Quoting field names (i.e., `"field"` vs `field`+                                 -- leads to nicer error messages.     show (UnknownKey k) = show k     show (ExtensionKey name) = "[" ++ intercalate "." name ++ "]"     show (UnknownExtensionKey k) = "[" ++ show k ++ "]"@@ -100,8 +103,15 @@     parseString = liftM (ByteStringValue . mconcat)         $ many1 $ lexeme ptp $ protoStringLiteral     parseEnumValue = liftM EnumValue (identifier ptp)-    parseMessageValue = liftM MessageValue-        (braces ptp parseMessage <|> angles ptp parseMessage)+    parseMessageValue =+        braces ptp (parseAny <|>+                    liftM (MessageValue Nothing) parseMessage) <|>+        angles ptp (liftM (MessageValue Nothing) parseMessage)++    typeUri = liftM StrictText.pack (many (satisfy (\c -> c /= ']' && not (isSpace c)))) <?>+              "type URI"+    parseAny = liftM2 MessageValue (liftM Just (brackets ptp typeUri))+                                   (braces ptp parseMessage)      makeNumberValue :: Bool -> Either Integer Double -> Value     makeNumberValue True (Left intValue) = IntValue (negate intValue)

@@ -0,0 +1,345 @@+{- This file was auto-generated from google/protobuf/compiler/plugin.proto by the proto-lens-protoc program. -}+{-# LANGUAGE ScopedTypeVariables, DataKinds, TypeFamilies,+  UndecidableInstances, GeneralizedNewtypeDeriving,+  MultiParamTypeClasses, FlexibleContexts, FlexibleInstances,+  PatternSynonyms, MagicHash, NoImplicitPrelude, DataKinds #-}+{-# OPTIONS_GHC -fno-warn-unused-imports#-}+{-# OPTIONS_GHC -fno-warn-duplicate-exports#-}+module Proto.Google.Protobuf.Compiler.Plugin+       (CodeGeneratorRequest(..), CodeGeneratorResponse(..),+        CodeGeneratorResponse'File(..))+       where+import qualified Lens.Labels.Prism+import qualified Prelude+import qualified Data.Int+import qualified Data.Word+import qualified Data.ProtoLens+import qualified Data.ProtoLens.Message.Enum+import qualified Data.ProtoLens.Service.Types+import qualified Lens.Family2+import qualified Lens.Family2.Unchecked+import qualified Data.Default.Class+import qualified Data.Text+import qualified Data.Map+import qualified Data.ByteString+import qualified Data.ByteString.Char8+import qualified Lens.Labels+import qualified Text.Read+import qualified Proto.Google.Protobuf.Descriptor++{- | Fields :++    * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.fileToGenerate' @:: Lens' CodeGeneratorRequest [Data.Text.Text]@+    * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.parameter' @:: Lens' CodeGeneratorRequest Data.Text.Text@+    * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.maybe'parameter' @:: Lens' CodeGeneratorRequest (Prelude.Maybe Data.Text.Text)@+    * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.protoFile' @:: Lens' CodeGeneratorRequest+  [Proto.Google.Protobuf.Descriptor.FileDescriptorProto]@+ -}+data CodeGeneratorRequest = CodeGeneratorRequest{_CodeGeneratorRequest'fileToGenerate+                                                 :: ![Data.Text.Text],+                                                 _CodeGeneratorRequest'parameter ::+                                                 !(Prelude.Maybe Data.Text.Text),+                                                 _CodeGeneratorRequest'protoFile ::+                                                 ![Proto.Google.Protobuf.Descriptor.FileDescriptorProto],+                                                 _CodeGeneratorRequest'_unknownFields ::+                                                 !Data.ProtoLens.FieldSet}+                          deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)+instance (Lens.Labels.HasLens' f CodeGeneratorRequest x a,+          a ~ b) =>+         Lens.Labels.HasLens f CodeGeneratorRequest CodeGeneratorRequest x a+           b+         where+        lensOf = Lens.Labels.lensOf'+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f CodeGeneratorRequest "fileToGenerate"+           ([Data.Text.Text])+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _CodeGeneratorRequest'fileToGenerate+                 (\ x__ y__ -> x__{_CodeGeneratorRequest'fileToGenerate = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f CodeGeneratorRequest "parameter"+           (Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _CodeGeneratorRequest'parameter+                 (\ x__ y__ -> x__{_CodeGeneratorRequest'parameter = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f CodeGeneratorRequest "maybe'parameter"+           (Prelude.Maybe Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _CodeGeneratorRequest'parameter+                 (\ x__ y__ -> x__{_CodeGeneratorRequest'parameter = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f CodeGeneratorRequest "protoFile"+           ([Proto.Google.Protobuf.Descriptor.FileDescriptorProto])+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _CodeGeneratorRequest'protoFile+                 (\ x__ y__ -> x__{_CodeGeneratorRequest'protoFile = y__}))+              Prelude.id+instance Data.Default.Class.Default CodeGeneratorRequest where+        def+          = CodeGeneratorRequest{_CodeGeneratorRequest'fileToGenerate = [],+                                 _CodeGeneratorRequest'parameter = Prelude.Nothing,+                                 _CodeGeneratorRequest'protoFile = [],+                                 _CodeGeneratorRequest'_unknownFields = ([])}+instance Data.ProtoLens.Message CodeGeneratorRequest where+        messageName _+          = Data.Text.pack "google.protobuf.compiler.CodeGeneratorRequest"+        fieldsByTag+          = let fileToGenerate__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "file_to_generate"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "fileToGenerate")))+                      :: Data.ProtoLens.FieldDescriptor CodeGeneratorRequest+                parameter__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "parameter"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'parameter")))+                      :: Data.ProtoLens.FieldDescriptor CodeGeneratorRequest+                protoFile__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "proto_file"+                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                         Data.ProtoLens.FieldTypeDescriptor+                           Proto.Google.Protobuf.Descriptor.FileDescriptorProto)+                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "protoFile")))+                      :: Data.ProtoLens.FieldDescriptor CodeGeneratorRequest+              in+              Data.Map.fromList+                [(Data.ProtoLens.Tag 1, fileToGenerate__field_descriptor),+                 (Data.ProtoLens.Tag 2, parameter__field_descriptor),+                 (Data.ProtoLens.Tag 15, protoFile__field_descriptor)]+        unknownFields+          = Lens.Family2.Unchecked.lens _CodeGeneratorRequest'_unknownFields+              (\ x__ y__ -> x__{_CodeGeneratorRequest'_unknownFields = y__})+{- | Fields :++    * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.error' @:: Lens' CodeGeneratorResponse Data.Text.Text@+    * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.maybe'error' @:: Lens' CodeGeneratorResponse (Prelude.Maybe Data.Text.Text)@+    * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.file' @:: Lens' CodeGeneratorResponse [CodeGeneratorResponse'File]@+ -}+data CodeGeneratorResponse = CodeGeneratorResponse{_CodeGeneratorResponse'error+                                                   :: !(Prelude.Maybe Data.Text.Text),+                                                   _CodeGeneratorResponse'file ::+                                                   ![CodeGeneratorResponse'File],+                                                   _CodeGeneratorResponse'_unknownFields ::+                                                   !Data.ProtoLens.FieldSet}+                           deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)+instance (Lens.Labels.HasLens' f CodeGeneratorResponse x a,+          a ~ b) =>+         Lens.Labels.HasLens f CodeGeneratorResponse CodeGeneratorResponse x+           a+           b+         where+        lensOf = Lens.Labels.lensOf'+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f CodeGeneratorResponse "error"+           (Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _CodeGeneratorResponse'error+                 (\ x__ y__ -> x__{_CodeGeneratorResponse'error = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f CodeGeneratorResponse "maybe'error"+           (Prelude.Maybe Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _CodeGeneratorResponse'error+                 (\ x__ y__ -> x__{_CodeGeneratorResponse'error = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f CodeGeneratorResponse "file"+           ([CodeGeneratorResponse'File])+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _CodeGeneratorResponse'file+                 (\ x__ y__ -> x__{_CodeGeneratorResponse'file = y__}))+              Prelude.id+instance Data.Default.Class.Default CodeGeneratorResponse where+        def+          = CodeGeneratorResponse{_CodeGeneratorResponse'error =+                                    Prelude.Nothing,+                                  _CodeGeneratorResponse'file = [],+                                  _CodeGeneratorResponse'_unknownFields = ([])}+instance Data.ProtoLens.Message CodeGeneratorResponse where+        messageName _+          = Data.Text.pack "google.protobuf.compiler.CodeGeneratorResponse"+        fieldsByTag+          = let error__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "error"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'error")))+                      :: Data.ProtoLens.FieldDescriptor CodeGeneratorResponse+                file__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "file"+                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                         Data.ProtoLens.FieldTypeDescriptor CodeGeneratorResponse'File)+                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "file")))+                      :: Data.ProtoLens.FieldDescriptor CodeGeneratorResponse+              in+              Data.Map.fromList+                [(Data.ProtoLens.Tag 1, error__field_descriptor),+                 (Data.ProtoLens.Tag 15, file__field_descriptor)]+        unknownFields+          = Lens.Family2.Unchecked.lens _CodeGeneratorResponse'_unknownFields+              (\ x__ y__ -> x__{_CodeGeneratorResponse'_unknownFields = y__})+{- | Fields :++    * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.name' @:: Lens' CodeGeneratorResponse'File Data.Text.Text@+    * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.maybe'name' @:: Lens' CodeGeneratorResponse'File (Prelude.Maybe Data.Text.Text)@+    * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.insertionPoint' @:: Lens' CodeGeneratorResponse'File Data.Text.Text@+    * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.maybe'insertionPoint' @:: Lens' CodeGeneratorResponse'File (Prelude.Maybe Data.Text.Text)@+    * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.content' @:: Lens' CodeGeneratorResponse'File Data.Text.Text@+    * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.maybe'content' @:: Lens' CodeGeneratorResponse'File (Prelude.Maybe Data.Text.Text)@+ -}+data CodeGeneratorResponse'File = CodeGeneratorResponse'File{_CodeGeneratorResponse'File'name+                                                             :: !(Prelude.Maybe Data.Text.Text),+                                                             _CodeGeneratorResponse'File'insertionPoint+                                                             :: !(Prelude.Maybe Data.Text.Text),+                                                             _CodeGeneratorResponse'File'content ::+                                                             !(Prelude.Maybe Data.Text.Text),+                                                             _CodeGeneratorResponse'File'_unknownFields+                                                             :: !Data.ProtoLens.FieldSet}+                                deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)+instance (Lens.Labels.HasLens' f CodeGeneratorResponse'File x a,+          a ~ b) =>+         Lens.Labels.HasLens f CodeGeneratorResponse'File+           CodeGeneratorResponse'File+           x+           a+           b+         where+        lensOf = Lens.Labels.lensOf'+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f CodeGeneratorResponse'File "name"+           (Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _CodeGeneratorResponse'File'name+                 (\ x__ y__ -> x__{_CodeGeneratorResponse'File'name = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f CodeGeneratorResponse'File "maybe'name"+           (Prelude.Maybe Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _CodeGeneratorResponse'File'name+                 (\ x__ y__ -> x__{_CodeGeneratorResponse'File'name = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f CodeGeneratorResponse'File "insertionPoint"+           (Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens+                 _CodeGeneratorResponse'File'insertionPoint+                 (\ x__ y__ ->+                    x__{_CodeGeneratorResponse'File'insertionPoint = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f CodeGeneratorResponse'File+           "maybe'insertionPoint"+           (Prelude.Maybe Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens+                 _CodeGeneratorResponse'File'insertionPoint+                 (\ x__ y__ ->+                    x__{_CodeGeneratorResponse'File'insertionPoint = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f CodeGeneratorResponse'File "content"+           (Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _CodeGeneratorResponse'File'content+                 (\ x__ y__ -> x__{_CodeGeneratorResponse'File'content = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f CodeGeneratorResponse'File "maybe'content"+           (Prelude.Maybe Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _CodeGeneratorResponse'File'content+                 (\ x__ y__ -> x__{_CodeGeneratorResponse'File'content = y__}))+              Prelude.id+instance Data.Default.Class.Default CodeGeneratorResponse'File+         where+        def+          = CodeGeneratorResponse'File{_CodeGeneratorResponse'File'name =+                                         Prelude.Nothing,+                                       _CodeGeneratorResponse'File'insertionPoint = Prelude.Nothing,+                                       _CodeGeneratorResponse'File'content = Prelude.Nothing,+                                       _CodeGeneratorResponse'File'_unknownFields = ([])}+instance Data.ProtoLens.Message CodeGeneratorResponse'File where+        messageName _+          = Data.Text.pack+              "google.protobuf.compiler.CodeGeneratorResponse.File"+        fieldsByTag+          = let name__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "name"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'name")))+                      :: Data.ProtoLens.FieldDescriptor CodeGeneratorResponse'File+                insertionPoint__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "insertion_point"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) ::+                               (Lens.Labels.Proxy#) "maybe'insertionPoint")))+                      :: Data.ProtoLens.FieldDescriptor CodeGeneratorResponse'File+                content__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "content"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'content")))+                      :: Data.ProtoLens.FieldDescriptor CodeGeneratorResponse'File+              in+              Data.Map.fromList+                [(Data.ProtoLens.Tag 1, name__field_descriptor),+                 (Data.ProtoLens.Tag 2, insertionPoint__field_descriptor),+                 (Data.ProtoLens.Tag 15, content__field_descriptor)]+        unknownFields+          = Lens.Family2.Unchecked.lens+              _CodeGeneratorResponse'File'_unknownFields+              (\ x__ y__ ->+                 x__{_CodeGeneratorResponse'File'_unknownFields = y__})

@@ -0,0 +1,109 @@+{- This file was auto-generated from google/protobuf/compiler/plugin.proto by the proto-lens-protoc program. -}+{-# LANGUAGE ScopedTypeVariables, DataKinds, TypeFamilies,+  UndecidableInstances, GeneralizedNewtypeDeriving,+  MultiParamTypeClasses, FlexibleContexts, FlexibleInstances,+  PatternSynonyms, MagicHash, NoImplicitPrelude, DataKinds #-}+{-# OPTIONS_GHC -fno-warn-unused-imports#-}+{-# OPTIONS_GHC -fno-warn-duplicate-exports#-}+module Proto.Google.Protobuf.Compiler.Plugin_Fields where+import qualified Prelude+import qualified Data.Int+import qualified Data.Word+import qualified Data.ProtoLens+import qualified Data.ProtoLens.Message.Enum+import qualified Data.ProtoLens.Service.Types+import qualified Lens.Family2+import qualified Lens.Family2.Unchecked+import qualified Data.Default.Class+import qualified Data.Text+import qualified Data.Map+import qualified Data.ByteString+import qualified Data.ByteString.Char8+import qualified Lens.Labels+import qualified Text.Read+import qualified Proto.Google.Protobuf.Descriptor++content ::+        forall f s t a b . (Lens.Labels.HasLens f s t "content" a b) =>+          Lens.Family2.LensLike f s t a b+content+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "content")+error ::+      forall f s t a b . (Lens.Labels.HasLens f s t "error" a b) =>+        Lens.Family2.LensLike f s t a b+error+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "error")+file ::+     forall f s t a b . (Lens.Labels.HasLens f s t "file" a b) =>+       Lens.Family2.LensLike f s t a b+file+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "file")+fileToGenerate ::+               forall f s t a b .+                 (Lens.Labels.HasLens f s t "fileToGenerate" a b) =>+                 Lens.Family2.LensLike f s t a b+fileToGenerate+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "fileToGenerate")+insertionPoint ::+               forall f s t a b .+                 (Lens.Labels.HasLens f s t "insertionPoint" a b) =>+                 Lens.Family2.LensLike f s t a b+insertionPoint+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "insertionPoint")+maybe'content ::+              forall f s t a b .+                (Lens.Labels.HasLens f s t "maybe'content" a b) =>+                Lens.Family2.LensLike f s t a b+maybe'content+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'content")+maybe'error ::+            forall f s t a b . (Lens.Labels.HasLens f s t "maybe'error" a b) =>+              Lens.Family2.LensLike f s t a b+maybe'error+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'error")+maybe'insertionPoint ::+                     forall f s t a b .+                       (Lens.Labels.HasLens f s t "maybe'insertionPoint" a b) =>+                       Lens.Family2.LensLike f s t a b+maybe'insertionPoint+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) ::+         (Lens.Labels.Proxy#) "maybe'insertionPoint")+maybe'name ::+           forall f s t a b . (Lens.Labels.HasLens f s t "maybe'name" a b) =>+             Lens.Family2.LensLike f s t a b+maybe'name+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'name")+maybe'parameter ::+                forall f s t a b .+                  (Lens.Labels.HasLens f s t "maybe'parameter" a b) =>+                  Lens.Family2.LensLike f s t a b+maybe'parameter+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'parameter")+name ::+     forall f s t a b . (Lens.Labels.HasLens f s t "name" a b) =>+       Lens.Family2.LensLike f s t a b+name+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "name")+parameter ::+          forall f s t a b . (Lens.Labels.HasLens f s t "parameter" a b) =>+            Lens.Family2.LensLike f s t a b+parameter+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "parameter")+protoFile ::+          forall f s t a b . (Lens.Labels.HasLens f s t "protoFile" a b) =>+            Lens.Family2.LensLike f s t a b+protoFile+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "protoFile")

@@ -0,0 +1,4182 @@+{- This file was auto-generated from google/protobuf/descriptor.proto by the proto-lens-protoc program. -}+{-# LANGUAGE ScopedTypeVariables, DataKinds, TypeFamilies,+  UndecidableInstances, GeneralizedNewtypeDeriving,+  MultiParamTypeClasses, FlexibleContexts, FlexibleInstances,+  PatternSynonyms, MagicHash, NoImplicitPrelude, DataKinds #-}+{-# OPTIONS_GHC -fno-warn-unused-imports#-}+{-# OPTIONS_GHC -fno-warn-duplicate-exports#-}+module Proto.Google.Protobuf.Descriptor+       (DescriptorProto(..), DescriptorProto'ExtensionRange(..),+        DescriptorProto'ReservedRange(..), EnumDescriptorProto(..),+        EnumOptions(..), EnumValueDescriptorProto(..),+        EnumValueOptions(..), FieldDescriptorProto(..),+        FieldDescriptorProto'Label(..), FieldDescriptorProto'Label(),+        FieldDescriptorProto'Type(..), FieldDescriptorProto'Type(),+        FieldOptions(..), FieldOptions'CType(..), FieldOptions'CType(),+        FieldOptions'JSType(..), FieldOptions'JSType(),+        FileDescriptorProto(..), FileDescriptorSet(..), FileOptions(..),+        FileOptions'OptimizeMode(..), FileOptions'OptimizeMode(),+        GeneratedCodeInfo(..), GeneratedCodeInfo'Annotation(..),+        MessageOptions(..), MethodDescriptorProto(..), MethodOptions(..),+        OneofDescriptorProto(..), ServiceDescriptorProto(..),+        ServiceOptions(..), SourceCodeInfo(..),+        SourceCodeInfo'Location(..), UninterpretedOption(..),+        UninterpretedOption'NamePart(..))+       where+import qualified Lens.Labels.Prism+import qualified Prelude+import qualified Data.Int+import qualified Data.Word+import qualified Data.ProtoLens+import qualified Data.ProtoLens.Message.Enum+import qualified Data.ProtoLens.Service.Types+import qualified Lens.Family2+import qualified Lens.Family2.Unchecked+import qualified Data.Default.Class+import qualified Data.Text+import qualified Data.Map+import qualified Data.ByteString+import qualified Data.ByteString.Char8+import qualified Lens.Labels+import qualified Text.Read++{- | Fields :++    * 'Proto.Google.Protobuf.Descriptor_Fields.name' @:: Lens' DescriptorProto Data.Text.Text@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'name' @:: Lens' DescriptorProto (Prelude.Maybe Data.Text.Text)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.field' @:: Lens' DescriptorProto [FieldDescriptorProto]@+    * 'Proto.Google.Protobuf.Descriptor_Fields.extension' @:: Lens' DescriptorProto [FieldDescriptorProto]@+    * 'Proto.Google.Protobuf.Descriptor_Fields.nestedType' @:: Lens' DescriptorProto [DescriptorProto]@+    * 'Proto.Google.Protobuf.Descriptor_Fields.enumType' @:: Lens' DescriptorProto [EnumDescriptorProto]@+    * 'Proto.Google.Protobuf.Descriptor_Fields.extensionRange' @:: Lens' DescriptorProto [DescriptorProto'ExtensionRange]@+    * 'Proto.Google.Protobuf.Descriptor_Fields.oneofDecl' @:: Lens' DescriptorProto [OneofDescriptorProto]@+    * 'Proto.Google.Protobuf.Descriptor_Fields.options' @:: Lens' DescriptorProto MessageOptions@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'options' @:: Lens' DescriptorProto (Prelude.Maybe MessageOptions)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.reservedRange' @:: Lens' DescriptorProto [DescriptorProto'ReservedRange]@+    * 'Proto.Google.Protobuf.Descriptor_Fields.reservedName' @:: Lens' DescriptorProto [Data.Text.Text]@+ -}+data DescriptorProto = DescriptorProto{_DescriptorProto'name ::+                                       !(Prelude.Maybe Data.Text.Text),+                                       _DescriptorProto'field :: ![FieldDescriptorProto],+                                       _DescriptorProto'extension :: ![FieldDescriptorProto],+                                       _DescriptorProto'nestedType :: ![DescriptorProto],+                                       _DescriptorProto'enumType :: ![EnumDescriptorProto],+                                       _DescriptorProto'extensionRange ::+                                       ![DescriptorProto'ExtensionRange],+                                       _DescriptorProto'oneofDecl :: ![OneofDescriptorProto],+                                       _DescriptorProto'options :: !(Prelude.Maybe MessageOptions),+                                       _DescriptorProto'reservedRange ::+                                       ![DescriptorProto'ReservedRange],+                                       _DescriptorProto'reservedName :: ![Data.Text.Text],+                                       _DescriptorProto'_unknownFields :: !Data.ProtoLens.FieldSet}+                     deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)+instance (Lens.Labels.HasLens' f DescriptorProto x a, a ~ b) =>+         Lens.Labels.HasLens f DescriptorProto DescriptorProto x a b+         where+        lensOf = Lens.Labels.lensOf'+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f DescriptorProto "name" (Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _DescriptorProto'name+                 (\ x__ y__ -> x__{_DescriptorProto'name = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f DescriptorProto "maybe'name"+           (Prelude.Maybe Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _DescriptorProto'name+                 (\ x__ y__ -> x__{_DescriptorProto'name = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f DescriptorProto "field"+           ([FieldDescriptorProto])+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _DescriptorProto'field+                 (\ x__ y__ -> x__{_DescriptorProto'field = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f DescriptorProto "extension"+           ([FieldDescriptorProto])+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _DescriptorProto'extension+                 (\ x__ y__ -> x__{_DescriptorProto'extension = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f DescriptorProto "nestedType"+           ([DescriptorProto])+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _DescriptorProto'nestedType+                 (\ x__ y__ -> x__{_DescriptorProto'nestedType = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f DescriptorProto "enumType"+           ([EnumDescriptorProto])+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _DescriptorProto'enumType+                 (\ x__ y__ -> x__{_DescriptorProto'enumType = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f DescriptorProto "extensionRange"+           ([DescriptorProto'ExtensionRange])+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _DescriptorProto'extensionRange+                 (\ x__ y__ -> x__{_DescriptorProto'extensionRange = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f DescriptorProto "oneofDecl"+           ([OneofDescriptorProto])+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _DescriptorProto'oneofDecl+                 (\ x__ y__ -> x__{_DescriptorProto'oneofDecl = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f DescriptorProto "options" (MessageOptions)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _DescriptorProto'options+                 (\ x__ y__ -> x__{_DescriptorProto'options = y__}))+              (Data.ProtoLens.maybeLens Data.Default.Class.def)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f DescriptorProto "maybe'options"+           (Prelude.Maybe MessageOptions)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _DescriptorProto'options+                 (\ x__ y__ -> x__{_DescriptorProto'options = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f DescriptorProto "reservedRange"+           ([DescriptorProto'ReservedRange])+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _DescriptorProto'reservedRange+                 (\ x__ y__ -> x__{_DescriptorProto'reservedRange = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f DescriptorProto "reservedName"+           ([Data.Text.Text])+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _DescriptorProto'reservedName+                 (\ x__ y__ -> x__{_DescriptorProto'reservedName = y__}))+              Prelude.id+instance Data.Default.Class.Default DescriptorProto where+        def+          = DescriptorProto{_DescriptorProto'name = Prelude.Nothing,+                            _DescriptorProto'field = [], _DescriptorProto'extension = [],+                            _DescriptorProto'nestedType = [], _DescriptorProto'enumType = [],+                            _DescriptorProto'extensionRange = [],+                            _DescriptorProto'oneofDecl = [],+                            _DescriptorProto'options = Prelude.Nothing,+                            _DescriptorProto'reservedRange = [],+                            _DescriptorProto'reservedName = [],+                            _DescriptorProto'_unknownFields = ([])}+instance Data.ProtoLens.Message DescriptorProto where+        messageName _ = Data.Text.pack "google.protobuf.DescriptorProto"+        fieldsByTag+          = let name__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "name"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'name")))+                      :: Data.ProtoLens.FieldDescriptor DescriptorProto+                field__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "field"+                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                         Data.ProtoLens.FieldTypeDescriptor FieldDescriptorProto)+                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "field")))+                      :: Data.ProtoLens.FieldDescriptor DescriptorProto+                extension__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "extension"+                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                         Data.ProtoLens.FieldTypeDescriptor FieldDescriptorProto)+                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "extension")))+                      :: Data.ProtoLens.FieldDescriptor DescriptorProto+                nestedType__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "nested_type"+                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                         Data.ProtoLens.FieldTypeDescriptor DescriptorProto)+                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "nestedType")))+                      :: Data.ProtoLens.FieldDescriptor DescriptorProto+                enumType__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "enum_type"+                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                         Data.ProtoLens.FieldTypeDescriptor EnumDescriptorProto)+                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "enumType")))+                      :: Data.ProtoLens.FieldDescriptor DescriptorProto+                extensionRange__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "extension_range"+                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                         Data.ProtoLens.FieldTypeDescriptor DescriptorProto'ExtensionRange)+                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "extensionRange")))+                      :: Data.ProtoLens.FieldDescriptor DescriptorProto+                oneofDecl__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "oneof_decl"+                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                         Data.ProtoLens.FieldTypeDescriptor OneofDescriptorProto)+                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "oneofDecl")))+                      :: Data.ProtoLens.FieldDescriptor DescriptorProto+                options__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "options"+                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                         Data.ProtoLens.FieldTypeDescriptor MessageOptions)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'options")))+                      :: Data.ProtoLens.FieldDescriptor DescriptorProto+                reservedRange__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "reserved_range"+                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                         Data.ProtoLens.FieldTypeDescriptor DescriptorProto'ReservedRange)+                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "reservedRange")))+                      :: Data.ProtoLens.FieldDescriptor DescriptorProto+                reservedName__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "reserved_name"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "reservedName")))+                      :: Data.ProtoLens.FieldDescriptor DescriptorProto+              in+              Data.Map.fromList+                [(Data.ProtoLens.Tag 1, name__field_descriptor),+                 (Data.ProtoLens.Tag 2, field__field_descriptor),+                 (Data.ProtoLens.Tag 6, extension__field_descriptor),+                 (Data.ProtoLens.Tag 3, nestedType__field_descriptor),+                 (Data.ProtoLens.Tag 4, enumType__field_descriptor),+                 (Data.ProtoLens.Tag 5, extensionRange__field_descriptor),+                 (Data.ProtoLens.Tag 8, oneofDecl__field_descriptor),+                 (Data.ProtoLens.Tag 7, options__field_descriptor),+                 (Data.ProtoLens.Tag 9, reservedRange__field_descriptor),+                 (Data.ProtoLens.Tag 10, reservedName__field_descriptor)]+        unknownFields+          = Lens.Family2.Unchecked.lens _DescriptorProto'_unknownFields+              (\ x__ y__ -> x__{_DescriptorProto'_unknownFields = y__})+{- | Fields :++    * 'Proto.Google.Protobuf.Descriptor_Fields.start' @:: Lens' DescriptorProto'ExtensionRange Data.Int.Int32@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'start' @:: Lens' DescriptorProto'ExtensionRange (Prelude.Maybe Data.Int.Int32)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.end' @:: Lens' DescriptorProto'ExtensionRange Data.Int.Int32@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'end' @:: Lens' DescriptorProto'ExtensionRange (Prelude.Maybe Data.Int.Int32)@+ -}+data DescriptorProto'ExtensionRange = DescriptorProto'ExtensionRange{_DescriptorProto'ExtensionRange'start+                                                                     ::+                                                                     !(Prelude.Maybe+                                                                         Data.Int.Int32),+                                                                     _DescriptorProto'ExtensionRange'end+                                                                     ::+                                                                     !(Prelude.Maybe+                                                                         Data.Int.Int32),+                                                                     _DescriptorProto'ExtensionRange'_unknownFields+                                                                     :: !Data.ProtoLens.FieldSet}+                                    deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)+instance (Lens.Labels.HasLens' f DescriptorProto'ExtensionRange x+            a,+          a ~ b) =>+         Lens.Labels.HasLens f DescriptorProto'ExtensionRange+           DescriptorProto'ExtensionRange+           x+           a+           b+         where+        lensOf = Lens.Labels.lensOf'+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f DescriptorProto'ExtensionRange "start"+           (Data.Int.Int32)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _DescriptorProto'ExtensionRange'start+                 (\ x__ y__ -> x__{_DescriptorProto'ExtensionRange'start = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f DescriptorProto'ExtensionRange "maybe'start"+           (Prelude.Maybe Data.Int.Int32)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _DescriptorProto'ExtensionRange'start+                 (\ x__ y__ -> x__{_DescriptorProto'ExtensionRange'start = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f DescriptorProto'ExtensionRange "end"+           (Data.Int.Int32)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _DescriptorProto'ExtensionRange'end+                 (\ x__ y__ -> x__{_DescriptorProto'ExtensionRange'end = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f DescriptorProto'ExtensionRange "maybe'end"+           (Prelude.Maybe Data.Int.Int32)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _DescriptorProto'ExtensionRange'end+                 (\ x__ y__ -> x__{_DescriptorProto'ExtensionRange'end = y__}))+              Prelude.id+instance Data.Default.Class.Default DescriptorProto'ExtensionRange+         where+        def+          = DescriptorProto'ExtensionRange{_DescriptorProto'ExtensionRange'start+                                             = Prelude.Nothing,+                                           _DescriptorProto'ExtensionRange'end = Prelude.Nothing,+                                           _DescriptorProto'ExtensionRange'_unknownFields = ([])}+instance Data.ProtoLens.Message DescriptorProto'ExtensionRange+         where+        messageName _+          = Data.Text.pack "google.protobuf.DescriptorProto.ExtensionRange"+        fieldsByTag+          = let start__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "start"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'start")))+                      :: Data.ProtoLens.FieldDescriptor DescriptorProto'ExtensionRange+                end__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "end"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'end")))+                      :: Data.ProtoLens.FieldDescriptor DescriptorProto'ExtensionRange+              in+              Data.Map.fromList+                [(Data.ProtoLens.Tag 1, start__field_descriptor),+                 (Data.ProtoLens.Tag 2, end__field_descriptor)]+        unknownFields+          = Lens.Family2.Unchecked.lens+              _DescriptorProto'ExtensionRange'_unknownFields+              (\ x__ y__ ->+                 x__{_DescriptorProto'ExtensionRange'_unknownFields = y__})+{- | Fields :++    * 'Proto.Google.Protobuf.Descriptor_Fields.start' @:: Lens' DescriptorProto'ReservedRange Data.Int.Int32@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'start' @:: Lens' DescriptorProto'ReservedRange (Prelude.Maybe Data.Int.Int32)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.end' @:: Lens' DescriptorProto'ReservedRange Data.Int.Int32@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'end' @:: Lens' DescriptorProto'ReservedRange (Prelude.Maybe Data.Int.Int32)@+ -}+data DescriptorProto'ReservedRange = DescriptorProto'ReservedRange{_DescriptorProto'ReservedRange'start+                                                                   ::+                                                                   !(Prelude.Maybe Data.Int.Int32),+                                                                   _DescriptorProto'ReservedRange'end+                                                                   ::+                                                                   !(Prelude.Maybe Data.Int.Int32),+                                                                   _DescriptorProto'ReservedRange'_unknownFields+                                                                   :: !Data.ProtoLens.FieldSet}+                                   deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)+instance (Lens.Labels.HasLens' f DescriptorProto'ReservedRange x a,+          a ~ b) =>+         Lens.Labels.HasLens f DescriptorProto'ReservedRange+           DescriptorProto'ReservedRange+           x+           a+           b+         where+        lensOf = Lens.Labels.lensOf'+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f DescriptorProto'ReservedRange "start"+           (Data.Int.Int32)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _DescriptorProto'ReservedRange'start+                 (\ x__ y__ -> x__{_DescriptorProto'ReservedRange'start = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f DescriptorProto'ReservedRange "maybe'start"+           (Prelude.Maybe Data.Int.Int32)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _DescriptorProto'ReservedRange'start+                 (\ x__ y__ -> x__{_DescriptorProto'ReservedRange'start = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f DescriptorProto'ReservedRange "end"+           (Data.Int.Int32)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _DescriptorProto'ReservedRange'end+                 (\ x__ y__ -> x__{_DescriptorProto'ReservedRange'end = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f DescriptorProto'ReservedRange "maybe'end"+           (Prelude.Maybe Data.Int.Int32)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _DescriptorProto'ReservedRange'end+                 (\ x__ y__ -> x__{_DescriptorProto'ReservedRange'end = y__}))+              Prelude.id+instance Data.Default.Class.Default DescriptorProto'ReservedRange+         where+        def+          = DescriptorProto'ReservedRange{_DescriptorProto'ReservedRange'start+                                            = Prelude.Nothing,+                                          _DescriptorProto'ReservedRange'end = Prelude.Nothing,+                                          _DescriptorProto'ReservedRange'_unknownFields = ([])}+instance Data.ProtoLens.Message DescriptorProto'ReservedRange where+        messageName _+          = Data.Text.pack "google.protobuf.DescriptorProto.ReservedRange"+        fieldsByTag+          = let start__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "start"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'start")))+                      :: Data.ProtoLens.FieldDescriptor DescriptorProto'ReservedRange+                end__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "end"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'end")))+                      :: Data.ProtoLens.FieldDescriptor DescriptorProto'ReservedRange+              in+              Data.Map.fromList+                [(Data.ProtoLens.Tag 1, start__field_descriptor),+                 (Data.ProtoLens.Tag 2, end__field_descriptor)]+        unknownFields+          = Lens.Family2.Unchecked.lens+              _DescriptorProto'ReservedRange'_unknownFields+              (\ x__ y__ ->+                 x__{_DescriptorProto'ReservedRange'_unknownFields = y__})+{- | Fields :++    * 'Proto.Google.Protobuf.Descriptor_Fields.name' @:: Lens' EnumDescriptorProto Data.Text.Text@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'name' @:: Lens' EnumDescriptorProto (Prelude.Maybe Data.Text.Text)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.value' @:: Lens' EnumDescriptorProto [EnumValueDescriptorProto]@+    * 'Proto.Google.Protobuf.Descriptor_Fields.options' @:: Lens' EnumDescriptorProto EnumOptions@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'options' @:: Lens' EnumDescriptorProto (Prelude.Maybe EnumOptions)@+ -}+data EnumDescriptorProto = EnumDescriptorProto{_EnumDescriptorProto'name+                                               :: !(Prelude.Maybe Data.Text.Text),+                                               _EnumDescriptorProto'value ::+                                               ![EnumValueDescriptorProto],+                                               _EnumDescriptorProto'options ::+                                               !(Prelude.Maybe EnumOptions),+                                               _EnumDescriptorProto'_unknownFields ::+                                               !Data.ProtoLens.FieldSet}+                         deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)+instance (Lens.Labels.HasLens' f EnumDescriptorProto x a, a ~ b) =>+         Lens.Labels.HasLens f EnumDescriptorProto EnumDescriptorProto x a b+         where+        lensOf = Lens.Labels.lensOf'+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f EnumDescriptorProto "name" (Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _EnumDescriptorProto'name+                 (\ x__ y__ -> x__{_EnumDescriptorProto'name = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f EnumDescriptorProto "maybe'name"+           (Prelude.Maybe Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _EnumDescriptorProto'name+                 (\ x__ y__ -> x__{_EnumDescriptorProto'name = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f EnumDescriptorProto "value"+           ([EnumValueDescriptorProto])+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _EnumDescriptorProto'value+                 (\ x__ y__ -> x__{_EnumDescriptorProto'value = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f EnumDescriptorProto "options" (EnumOptions)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _EnumDescriptorProto'options+                 (\ x__ y__ -> x__{_EnumDescriptorProto'options = y__}))+              (Data.ProtoLens.maybeLens Data.Default.Class.def)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f EnumDescriptorProto "maybe'options"+           (Prelude.Maybe EnumOptions)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _EnumDescriptorProto'options+                 (\ x__ y__ -> x__{_EnumDescriptorProto'options = y__}))+              Prelude.id+instance Data.Default.Class.Default EnumDescriptorProto where+        def+          = EnumDescriptorProto{_EnumDescriptorProto'name = Prelude.Nothing,+                                _EnumDescriptorProto'value = [],+                                _EnumDescriptorProto'options = Prelude.Nothing,+                                _EnumDescriptorProto'_unknownFields = ([])}+instance Data.ProtoLens.Message EnumDescriptorProto where+        messageName _+          = Data.Text.pack "google.protobuf.EnumDescriptorProto"+        fieldsByTag+          = let name__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "name"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'name")))+                      :: Data.ProtoLens.FieldDescriptor EnumDescriptorProto+                value__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "value"+                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                         Data.ProtoLens.FieldTypeDescriptor EnumValueDescriptorProto)+                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "value")))+                      :: Data.ProtoLens.FieldDescriptor EnumDescriptorProto+                options__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "options"+                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                         Data.ProtoLens.FieldTypeDescriptor EnumOptions)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'options")))+                      :: Data.ProtoLens.FieldDescriptor EnumDescriptorProto+              in+              Data.Map.fromList+                [(Data.ProtoLens.Tag 1, name__field_descriptor),+                 (Data.ProtoLens.Tag 2, value__field_descriptor),+                 (Data.ProtoLens.Tag 3, options__field_descriptor)]+        unknownFields+          = Lens.Family2.Unchecked.lens _EnumDescriptorProto'_unknownFields+              (\ x__ y__ -> x__{_EnumDescriptorProto'_unknownFields = y__})+{- | Fields :++    * 'Proto.Google.Protobuf.Descriptor_Fields.allowAlias' @:: Lens' EnumOptions Prelude.Bool@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'allowAlias' @:: Lens' EnumOptions (Prelude.Maybe Prelude.Bool)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.deprecated' @:: Lens' EnumOptions Prelude.Bool@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'deprecated' @:: Lens' EnumOptions (Prelude.Maybe Prelude.Bool)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.uninterpretedOption' @:: Lens' EnumOptions [UninterpretedOption]@+ -}+data EnumOptions = EnumOptions{_EnumOptions'allowAlias ::+                               !(Prelude.Maybe Prelude.Bool),+                               _EnumOptions'deprecated :: !(Prelude.Maybe Prelude.Bool),+                               _EnumOptions'uninterpretedOption :: ![UninterpretedOption],+                               _EnumOptions'_unknownFields :: !Data.ProtoLens.FieldSet}+                 deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)+instance (Lens.Labels.HasLens' f EnumOptions x a, a ~ b) =>+         Lens.Labels.HasLens f EnumOptions EnumOptions x a b+         where+        lensOf = Lens.Labels.lensOf'+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f EnumOptions "allowAlias" (Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _EnumOptions'allowAlias+                 (\ x__ y__ -> x__{_EnumOptions'allowAlias = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f EnumOptions "maybe'allowAlias"+           (Prelude.Maybe Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _EnumOptions'allowAlias+                 (\ x__ y__ -> x__{_EnumOptions'allowAlias = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f EnumOptions "deprecated" (Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _EnumOptions'deprecated+                 (\ x__ y__ -> x__{_EnumOptions'deprecated = y__}))+              (Data.ProtoLens.maybeLens Prelude.False)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f EnumOptions "maybe'deprecated"+           (Prelude.Maybe Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _EnumOptions'deprecated+                 (\ x__ y__ -> x__{_EnumOptions'deprecated = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f EnumOptions "uninterpretedOption"+           ([UninterpretedOption])+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _EnumOptions'uninterpretedOption+                 (\ x__ y__ -> x__{_EnumOptions'uninterpretedOption = y__}))+              Prelude.id+instance Data.Default.Class.Default EnumOptions where+        def+          = EnumOptions{_EnumOptions'allowAlias = Prelude.Nothing,+                        _EnumOptions'deprecated = Prelude.Nothing,+                        _EnumOptions'uninterpretedOption = [],+                        _EnumOptions'_unknownFields = ([])}+instance Data.ProtoLens.Message EnumOptions where+        messageName _ = Data.Text.pack "google.protobuf.EnumOptions"+        fieldsByTag+          = let allowAlias__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "allow_alias"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'allowAlias")))+                      :: Data.ProtoLens.FieldDescriptor EnumOptions+                deprecated__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "deprecated"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'deprecated")))+                      :: Data.ProtoLens.FieldDescriptor EnumOptions+                uninterpretedOption__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "uninterpreted_option"+                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                         Data.ProtoLens.FieldTypeDescriptor UninterpretedOption)+                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) ::+                               (Lens.Labels.Proxy#) "uninterpretedOption")))+                      :: Data.ProtoLens.FieldDescriptor EnumOptions+              in+              Data.Map.fromList+                [(Data.ProtoLens.Tag 2, allowAlias__field_descriptor),+                 (Data.ProtoLens.Tag 3, deprecated__field_descriptor),+                 (Data.ProtoLens.Tag 999, uninterpretedOption__field_descriptor)]+        unknownFields+          = Lens.Family2.Unchecked.lens _EnumOptions'_unknownFields+              (\ x__ y__ -> x__{_EnumOptions'_unknownFields = y__})+{- | Fields :++    * 'Proto.Google.Protobuf.Descriptor_Fields.name' @:: Lens' EnumValueDescriptorProto Data.Text.Text@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'name' @:: Lens' EnumValueDescriptorProto (Prelude.Maybe Data.Text.Text)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.number' @:: Lens' EnumValueDescriptorProto Data.Int.Int32@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'number' @:: Lens' EnumValueDescriptorProto (Prelude.Maybe Data.Int.Int32)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.options' @:: Lens' EnumValueDescriptorProto EnumValueOptions@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'options' @:: Lens' EnumValueDescriptorProto (Prelude.Maybe EnumValueOptions)@+ -}+data EnumValueDescriptorProto = EnumValueDescriptorProto{_EnumValueDescriptorProto'name+                                                         :: !(Prelude.Maybe Data.Text.Text),+                                                         _EnumValueDescriptorProto'number ::+                                                         !(Prelude.Maybe Data.Int.Int32),+                                                         _EnumValueDescriptorProto'options ::+                                                         !(Prelude.Maybe EnumValueOptions),+                                                         _EnumValueDescriptorProto'_unknownFields ::+                                                         !Data.ProtoLens.FieldSet}+                              deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)+instance (Lens.Labels.HasLens' f EnumValueDescriptorProto x a,+          a ~ b) =>+         Lens.Labels.HasLens f EnumValueDescriptorProto+           EnumValueDescriptorProto+           x+           a+           b+         where+        lensOf = Lens.Labels.lensOf'+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f EnumValueDescriptorProto "name"+           (Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _EnumValueDescriptorProto'name+                 (\ x__ y__ -> x__{_EnumValueDescriptorProto'name = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f EnumValueDescriptorProto "maybe'name"+           (Prelude.Maybe Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _EnumValueDescriptorProto'name+                 (\ x__ y__ -> x__{_EnumValueDescriptorProto'name = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f EnumValueDescriptorProto "number"+           (Data.Int.Int32)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _EnumValueDescriptorProto'number+                 (\ x__ y__ -> x__{_EnumValueDescriptorProto'number = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f EnumValueDescriptorProto "maybe'number"+           (Prelude.Maybe Data.Int.Int32)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _EnumValueDescriptorProto'number+                 (\ x__ y__ -> x__{_EnumValueDescriptorProto'number = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f EnumValueDescriptorProto "options"+           (EnumValueOptions)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _EnumValueDescriptorProto'options+                 (\ x__ y__ -> x__{_EnumValueDescriptorProto'options = y__}))+              (Data.ProtoLens.maybeLens Data.Default.Class.def)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f EnumValueDescriptorProto "maybe'options"+           (Prelude.Maybe EnumValueOptions)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _EnumValueDescriptorProto'options+                 (\ x__ y__ -> x__{_EnumValueDescriptorProto'options = y__}))+              Prelude.id+instance Data.Default.Class.Default EnumValueDescriptorProto where+        def+          = EnumValueDescriptorProto{_EnumValueDescriptorProto'name =+                                       Prelude.Nothing,+                                     _EnumValueDescriptorProto'number = Prelude.Nothing,+                                     _EnumValueDescriptorProto'options = Prelude.Nothing,+                                     _EnumValueDescriptorProto'_unknownFields = ([])}+instance Data.ProtoLens.Message EnumValueDescriptorProto where+        messageName _+          = Data.Text.pack "google.protobuf.EnumValueDescriptorProto"+        fieldsByTag+          = let name__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "name"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'name")))+                      :: Data.ProtoLens.FieldDescriptor EnumValueDescriptorProto+                number__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "number"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'number")))+                      :: Data.ProtoLens.FieldDescriptor EnumValueDescriptorProto+                options__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "options"+                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                         Data.ProtoLens.FieldTypeDescriptor EnumValueOptions)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'options")))+                      :: Data.ProtoLens.FieldDescriptor EnumValueDescriptorProto+              in+              Data.Map.fromList+                [(Data.ProtoLens.Tag 1, name__field_descriptor),+                 (Data.ProtoLens.Tag 2, number__field_descriptor),+                 (Data.ProtoLens.Tag 3, options__field_descriptor)]+        unknownFields+          = Lens.Family2.Unchecked.lens+              _EnumValueDescriptorProto'_unknownFields+              (\ x__ y__ -> x__{_EnumValueDescriptorProto'_unknownFields = y__})+{- | Fields :++    * 'Proto.Google.Protobuf.Descriptor_Fields.deprecated' @:: Lens' EnumValueOptions Prelude.Bool@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'deprecated' @:: Lens' EnumValueOptions (Prelude.Maybe Prelude.Bool)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.uninterpretedOption' @:: Lens' EnumValueOptions [UninterpretedOption]@+ -}+data EnumValueOptions = EnumValueOptions{_EnumValueOptions'deprecated+                                         :: !(Prelude.Maybe Prelude.Bool),+                                         _EnumValueOptions'uninterpretedOption ::+                                         ![UninterpretedOption],+                                         _EnumValueOptions'_unknownFields ::+                                         !Data.ProtoLens.FieldSet}+                      deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)+instance (Lens.Labels.HasLens' f EnumValueOptions x a, a ~ b) =>+         Lens.Labels.HasLens f EnumValueOptions EnumValueOptions x a b+         where+        lensOf = Lens.Labels.lensOf'+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f EnumValueOptions "deprecated" (Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _EnumValueOptions'deprecated+                 (\ x__ y__ -> x__{_EnumValueOptions'deprecated = y__}))+              (Data.ProtoLens.maybeLens Prelude.False)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f EnumValueOptions "maybe'deprecated"+           (Prelude.Maybe Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _EnumValueOptions'deprecated+                 (\ x__ y__ -> x__{_EnumValueOptions'deprecated = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f EnumValueOptions "uninterpretedOption"+           ([UninterpretedOption])+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _EnumValueOptions'uninterpretedOption+                 (\ x__ y__ -> x__{_EnumValueOptions'uninterpretedOption = y__}))+              Prelude.id+instance Data.Default.Class.Default EnumValueOptions where+        def+          = EnumValueOptions{_EnumValueOptions'deprecated = Prelude.Nothing,+                             _EnumValueOptions'uninterpretedOption = [],+                             _EnumValueOptions'_unknownFields = ([])}+instance Data.ProtoLens.Message EnumValueOptions where+        messageName _ = Data.Text.pack "google.protobuf.EnumValueOptions"+        fieldsByTag+          = let deprecated__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "deprecated"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'deprecated")))+                      :: Data.ProtoLens.FieldDescriptor EnumValueOptions+                uninterpretedOption__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "uninterpreted_option"+                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                         Data.ProtoLens.FieldTypeDescriptor UninterpretedOption)+                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) ::+                               (Lens.Labels.Proxy#) "uninterpretedOption")))+                      :: Data.ProtoLens.FieldDescriptor EnumValueOptions+              in+              Data.Map.fromList+                [(Data.ProtoLens.Tag 1, deprecated__field_descriptor),+                 (Data.ProtoLens.Tag 999, uninterpretedOption__field_descriptor)]+        unknownFields+          = Lens.Family2.Unchecked.lens _EnumValueOptions'_unknownFields+              (\ x__ y__ -> x__{_EnumValueOptions'_unknownFields = y__})+{- | Fields :++    * 'Proto.Google.Protobuf.Descriptor_Fields.name' @:: Lens' FieldDescriptorProto Data.Text.Text@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'name' @:: Lens' FieldDescriptorProto (Prelude.Maybe Data.Text.Text)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.number' @:: Lens' FieldDescriptorProto Data.Int.Int32@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'number' @:: Lens' FieldDescriptorProto (Prelude.Maybe Data.Int.Int32)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.label' @:: Lens' FieldDescriptorProto FieldDescriptorProto'Label@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'label' @:: Lens' FieldDescriptorProto+  (Prelude.Maybe FieldDescriptorProto'Label)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.type'' @:: Lens' FieldDescriptorProto FieldDescriptorProto'Type@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'type'' @:: Lens' FieldDescriptorProto+  (Prelude.Maybe FieldDescriptorProto'Type)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.typeName' @:: Lens' FieldDescriptorProto Data.Text.Text@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'typeName' @:: Lens' FieldDescriptorProto (Prelude.Maybe Data.Text.Text)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.extendee' @:: Lens' FieldDescriptorProto Data.Text.Text@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'extendee' @:: Lens' FieldDescriptorProto (Prelude.Maybe Data.Text.Text)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.defaultValue' @:: Lens' FieldDescriptorProto Data.Text.Text@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'defaultValue' @:: Lens' FieldDescriptorProto (Prelude.Maybe Data.Text.Text)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.oneofIndex' @:: Lens' FieldDescriptorProto Data.Int.Int32@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'oneofIndex' @:: Lens' FieldDescriptorProto (Prelude.Maybe Data.Int.Int32)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.jsonName' @:: Lens' FieldDescriptorProto Data.Text.Text@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'jsonName' @:: Lens' FieldDescriptorProto (Prelude.Maybe Data.Text.Text)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.options' @:: Lens' FieldDescriptorProto FieldOptions@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'options' @:: Lens' FieldDescriptorProto (Prelude.Maybe FieldOptions)@+ -}+data FieldDescriptorProto = FieldDescriptorProto{_FieldDescriptorProto'name+                                                 :: !(Prelude.Maybe Data.Text.Text),+                                                 _FieldDescriptorProto'number ::+                                                 !(Prelude.Maybe Data.Int.Int32),+                                                 _FieldDescriptorProto'label ::+                                                 !(Prelude.Maybe FieldDescriptorProto'Label),+                                                 _FieldDescriptorProto'type' ::+                                                 !(Prelude.Maybe FieldDescriptorProto'Type),+                                                 _FieldDescriptorProto'typeName ::+                                                 !(Prelude.Maybe Data.Text.Text),+                                                 _FieldDescriptorProto'extendee ::+                                                 !(Prelude.Maybe Data.Text.Text),+                                                 _FieldDescriptorProto'defaultValue ::+                                                 !(Prelude.Maybe Data.Text.Text),+                                                 _FieldDescriptorProto'oneofIndex ::+                                                 !(Prelude.Maybe Data.Int.Int32),+                                                 _FieldDescriptorProto'jsonName ::+                                                 !(Prelude.Maybe Data.Text.Text),+                                                 _FieldDescriptorProto'options ::+                                                 !(Prelude.Maybe FieldOptions),+                                                 _FieldDescriptorProto'_unknownFields ::+                                                 !Data.ProtoLens.FieldSet}+                          deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)+instance (Lens.Labels.HasLens' f FieldDescriptorProto x a,+          a ~ b) =>+         Lens.Labels.HasLens f FieldDescriptorProto FieldDescriptorProto x a+           b+         where+        lensOf = Lens.Labels.lensOf'+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FieldDescriptorProto "name" (Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FieldDescriptorProto'name+                 (\ x__ y__ -> x__{_FieldDescriptorProto'name = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FieldDescriptorProto "maybe'name"+           (Prelude.Maybe Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FieldDescriptorProto'name+                 (\ x__ y__ -> x__{_FieldDescriptorProto'name = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FieldDescriptorProto "number"+           (Data.Int.Int32)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FieldDescriptorProto'number+                 (\ x__ y__ -> x__{_FieldDescriptorProto'number = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FieldDescriptorProto "maybe'number"+           (Prelude.Maybe Data.Int.Int32)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FieldDescriptorProto'number+                 (\ x__ y__ -> x__{_FieldDescriptorProto'number = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FieldDescriptorProto "label"+           (FieldDescriptorProto'Label)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FieldDescriptorProto'label+                 (\ x__ y__ -> x__{_FieldDescriptorProto'label = y__}))+              (Data.ProtoLens.maybeLens Data.Default.Class.def)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FieldDescriptorProto "maybe'label"+           (Prelude.Maybe FieldDescriptorProto'Label)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FieldDescriptorProto'label+                 (\ x__ y__ -> x__{_FieldDescriptorProto'label = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FieldDescriptorProto "type'"+           (FieldDescriptorProto'Type)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FieldDescriptorProto'type'+                 (\ x__ y__ -> x__{_FieldDescriptorProto'type' = y__}))+              (Data.ProtoLens.maybeLens Data.Default.Class.def)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FieldDescriptorProto "maybe'type'"+           (Prelude.Maybe FieldDescriptorProto'Type)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FieldDescriptorProto'type'+                 (\ x__ y__ -> x__{_FieldDescriptorProto'type' = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FieldDescriptorProto "typeName"+           (Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FieldDescriptorProto'typeName+                 (\ x__ y__ -> x__{_FieldDescriptorProto'typeName = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FieldDescriptorProto "maybe'typeName"+           (Prelude.Maybe Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FieldDescriptorProto'typeName+                 (\ x__ y__ -> x__{_FieldDescriptorProto'typeName = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FieldDescriptorProto "extendee"+           (Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FieldDescriptorProto'extendee+                 (\ x__ y__ -> x__{_FieldDescriptorProto'extendee = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FieldDescriptorProto "maybe'extendee"+           (Prelude.Maybe Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FieldDescriptorProto'extendee+                 (\ x__ y__ -> x__{_FieldDescriptorProto'extendee = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FieldDescriptorProto "defaultValue"+           (Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FieldDescriptorProto'defaultValue+                 (\ x__ y__ -> x__{_FieldDescriptorProto'defaultValue = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FieldDescriptorProto "maybe'defaultValue"+           (Prelude.Maybe Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FieldDescriptorProto'defaultValue+                 (\ x__ y__ -> x__{_FieldDescriptorProto'defaultValue = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FieldDescriptorProto "oneofIndex"+           (Data.Int.Int32)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FieldDescriptorProto'oneofIndex+                 (\ x__ y__ -> x__{_FieldDescriptorProto'oneofIndex = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FieldDescriptorProto "maybe'oneofIndex"+           (Prelude.Maybe Data.Int.Int32)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FieldDescriptorProto'oneofIndex+                 (\ x__ y__ -> x__{_FieldDescriptorProto'oneofIndex = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FieldDescriptorProto "jsonName"+           (Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FieldDescriptorProto'jsonName+                 (\ x__ y__ -> x__{_FieldDescriptorProto'jsonName = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FieldDescriptorProto "maybe'jsonName"+           (Prelude.Maybe Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FieldDescriptorProto'jsonName+                 (\ x__ y__ -> x__{_FieldDescriptorProto'jsonName = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FieldDescriptorProto "options"+           (FieldOptions)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FieldDescriptorProto'options+                 (\ x__ y__ -> x__{_FieldDescriptorProto'options = y__}))+              (Data.ProtoLens.maybeLens Data.Default.Class.def)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FieldDescriptorProto "maybe'options"+           (Prelude.Maybe FieldOptions)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FieldDescriptorProto'options+                 (\ x__ y__ -> x__{_FieldDescriptorProto'options = y__}))+              Prelude.id+instance Data.Default.Class.Default FieldDescriptorProto where+        def+          = FieldDescriptorProto{_FieldDescriptorProto'name =+                                   Prelude.Nothing,+                                 _FieldDescriptorProto'number = Prelude.Nothing,+                                 _FieldDescriptorProto'label = Prelude.Nothing,+                                 _FieldDescriptorProto'type' = Prelude.Nothing,+                                 _FieldDescriptorProto'typeName = Prelude.Nothing,+                                 _FieldDescriptorProto'extendee = Prelude.Nothing,+                                 _FieldDescriptorProto'defaultValue = Prelude.Nothing,+                                 _FieldDescriptorProto'oneofIndex = Prelude.Nothing,+                                 _FieldDescriptorProto'jsonName = Prelude.Nothing,+                                 _FieldDescriptorProto'options = Prelude.Nothing,+                                 _FieldDescriptorProto'_unknownFields = ([])}+instance Data.ProtoLens.Message FieldDescriptorProto where+        messageName _+          = Data.Text.pack "google.protobuf.FieldDescriptorProto"+        fieldsByTag+          = let name__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "name"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'name")))+                      :: Data.ProtoLens.FieldDescriptor FieldDescriptorProto+                number__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "number"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'number")))+                      :: Data.ProtoLens.FieldDescriptor FieldDescriptorProto+                label__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "label"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField ::+                         Data.ProtoLens.FieldTypeDescriptor FieldDescriptorProto'Label)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'label")))+                      :: Data.ProtoLens.FieldDescriptor FieldDescriptorProto+                type'__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "type"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField ::+                         Data.ProtoLens.FieldTypeDescriptor FieldDescriptorProto'Type)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'type'")))+                      :: Data.ProtoLens.FieldDescriptor FieldDescriptorProto+                typeName__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "type_name"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'typeName")))+                      :: Data.ProtoLens.FieldDescriptor FieldDescriptorProto+                extendee__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "extendee"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'extendee")))+                      :: Data.ProtoLens.FieldDescriptor FieldDescriptorProto+                defaultValue__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "default_value"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) ::+                               (Lens.Labels.Proxy#) "maybe'defaultValue")))+                      :: Data.ProtoLens.FieldDescriptor FieldDescriptorProto+                oneofIndex__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "oneof_index"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'oneofIndex")))+                      :: Data.ProtoLens.FieldDescriptor FieldDescriptorProto+                jsonName__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "json_name"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'jsonName")))+                      :: Data.ProtoLens.FieldDescriptor FieldDescriptorProto+                options__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "options"+                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                         Data.ProtoLens.FieldTypeDescriptor FieldOptions)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'options")))+                      :: Data.ProtoLens.FieldDescriptor FieldDescriptorProto+              in+              Data.Map.fromList+                [(Data.ProtoLens.Tag 1, name__field_descriptor),+                 (Data.ProtoLens.Tag 3, number__field_descriptor),+                 (Data.ProtoLens.Tag 4, label__field_descriptor),+                 (Data.ProtoLens.Tag 5, type'__field_descriptor),+                 (Data.ProtoLens.Tag 6, typeName__field_descriptor),+                 (Data.ProtoLens.Tag 2, extendee__field_descriptor),+                 (Data.ProtoLens.Tag 7, defaultValue__field_descriptor),+                 (Data.ProtoLens.Tag 9, oneofIndex__field_descriptor),+                 (Data.ProtoLens.Tag 10, jsonName__field_descriptor),+                 (Data.ProtoLens.Tag 8, options__field_descriptor)]+        unknownFields+          = Lens.Family2.Unchecked.lens _FieldDescriptorProto'_unknownFields+              (\ x__ y__ -> x__{_FieldDescriptorProto'_unknownFields = y__})+data FieldDescriptorProto'Label = FieldDescriptorProto'LABEL_OPTIONAL+                                | FieldDescriptorProto'LABEL_REQUIRED+                                | FieldDescriptorProto'LABEL_REPEATED+                                deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)+instance Data.Default.Class.Default FieldDescriptorProto'Label+         where+        def = FieldDescriptorProto'LABEL_OPTIONAL+instance Data.ProtoLens.FieldDefault FieldDescriptorProto'Label+         where+        fieldDefault = FieldDescriptorProto'LABEL_OPTIONAL+instance Data.ProtoLens.MessageEnum FieldDescriptorProto'Label+         where+        maybeToEnum 1 = Prelude.Just FieldDescriptorProto'LABEL_OPTIONAL+        maybeToEnum 2 = Prelude.Just FieldDescriptorProto'LABEL_REQUIRED+        maybeToEnum 3 = Prelude.Just FieldDescriptorProto'LABEL_REPEATED+        maybeToEnum _ = Prelude.Nothing+        showEnum FieldDescriptorProto'LABEL_OPTIONAL = "LABEL_OPTIONAL"+        showEnum FieldDescriptorProto'LABEL_REQUIRED = "LABEL_REQUIRED"+        showEnum FieldDescriptorProto'LABEL_REPEATED = "LABEL_REPEATED"+        readEnum "LABEL_OPTIONAL"+          = Prelude.Just FieldDescriptorProto'LABEL_OPTIONAL+        readEnum "LABEL_REQUIRED"+          = Prelude.Just FieldDescriptorProto'LABEL_REQUIRED+        readEnum "LABEL_REPEATED"+          = Prelude.Just FieldDescriptorProto'LABEL_REPEATED+        readEnum _ = Prelude.Nothing+instance Prelude.Enum FieldDescriptorProto'Label where+        toEnum k__+          = Prelude.maybe+              (Prelude.error+                 ((Prelude.++) "toEnum: unknown value for enum Label: "+                    (Prelude.show k__)))+              Prelude.id+              (Data.ProtoLens.maybeToEnum k__)+        fromEnum FieldDescriptorProto'LABEL_OPTIONAL = 1+        fromEnum FieldDescriptorProto'LABEL_REQUIRED = 2+        fromEnum FieldDescriptorProto'LABEL_REPEATED = 3+        succ FieldDescriptorProto'LABEL_REPEATED+          = Prelude.error+              "FieldDescriptorProto'Label.succ: bad argument FieldDescriptorProto'LABEL_REPEATED. This value would be out of bounds."+        succ FieldDescriptorProto'LABEL_OPTIONAL+          = FieldDescriptorProto'LABEL_REQUIRED+        succ FieldDescriptorProto'LABEL_REQUIRED+          = FieldDescriptorProto'LABEL_REPEATED+        pred FieldDescriptorProto'LABEL_OPTIONAL+          = Prelude.error+              "FieldDescriptorProto'Label.pred: bad argument FieldDescriptorProto'LABEL_OPTIONAL. This value would be out of bounds."+        pred FieldDescriptorProto'LABEL_REQUIRED+          = FieldDescriptorProto'LABEL_OPTIONAL+        pred FieldDescriptorProto'LABEL_REPEATED+          = FieldDescriptorProto'LABEL_REQUIRED+        enumFrom = Data.ProtoLens.Message.Enum.messageEnumFrom+        enumFromTo = Data.ProtoLens.Message.Enum.messageEnumFromTo+        enumFromThen = Data.ProtoLens.Message.Enum.messageEnumFromThen+        enumFromThenTo = Data.ProtoLens.Message.Enum.messageEnumFromThenTo+instance Prelude.Bounded FieldDescriptorProto'Label where+        minBound = FieldDescriptorProto'LABEL_OPTIONAL+        maxBound = FieldDescriptorProto'LABEL_REPEATED+data FieldDescriptorProto'Type = FieldDescriptorProto'TYPE_DOUBLE+                               | FieldDescriptorProto'TYPE_FLOAT+                               | FieldDescriptorProto'TYPE_INT64+                               | FieldDescriptorProto'TYPE_UINT64+                               | FieldDescriptorProto'TYPE_INT32+                               | FieldDescriptorProto'TYPE_FIXED64+                               | FieldDescriptorProto'TYPE_FIXED32+                               | FieldDescriptorProto'TYPE_BOOL+                               | FieldDescriptorProto'TYPE_STRING+                               | FieldDescriptorProto'TYPE_GROUP+                               | FieldDescriptorProto'TYPE_MESSAGE+                               | FieldDescriptorProto'TYPE_BYTES+                               | FieldDescriptorProto'TYPE_UINT32+                               | FieldDescriptorProto'TYPE_ENUM+                               | FieldDescriptorProto'TYPE_SFIXED32+                               | FieldDescriptorProto'TYPE_SFIXED64+                               | FieldDescriptorProto'TYPE_SINT32+                               | FieldDescriptorProto'TYPE_SINT64+                               deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)+instance Data.Default.Class.Default FieldDescriptorProto'Type where+        def = FieldDescriptorProto'TYPE_DOUBLE+instance Data.ProtoLens.FieldDefault FieldDescriptorProto'Type+         where+        fieldDefault = FieldDescriptorProto'TYPE_DOUBLE+instance Data.ProtoLens.MessageEnum FieldDescriptorProto'Type where+        maybeToEnum 1 = Prelude.Just FieldDescriptorProto'TYPE_DOUBLE+        maybeToEnum 2 = Prelude.Just FieldDescriptorProto'TYPE_FLOAT+        maybeToEnum 3 = Prelude.Just FieldDescriptorProto'TYPE_INT64+        maybeToEnum 4 = Prelude.Just FieldDescriptorProto'TYPE_UINT64+        maybeToEnum 5 = Prelude.Just FieldDescriptorProto'TYPE_INT32+        maybeToEnum 6 = Prelude.Just FieldDescriptorProto'TYPE_FIXED64+        maybeToEnum 7 = Prelude.Just FieldDescriptorProto'TYPE_FIXED32+        maybeToEnum 8 = Prelude.Just FieldDescriptorProto'TYPE_BOOL+        maybeToEnum 9 = Prelude.Just FieldDescriptorProto'TYPE_STRING+        maybeToEnum 10 = Prelude.Just FieldDescriptorProto'TYPE_GROUP+        maybeToEnum 11 = Prelude.Just FieldDescriptorProto'TYPE_MESSAGE+        maybeToEnum 12 = Prelude.Just FieldDescriptorProto'TYPE_BYTES+        maybeToEnum 13 = Prelude.Just FieldDescriptorProto'TYPE_UINT32+        maybeToEnum 14 = Prelude.Just FieldDescriptorProto'TYPE_ENUM+        maybeToEnum 15 = Prelude.Just FieldDescriptorProto'TYPE_SFIXED32+        maybeToEnum 16 = Prelude.Just FieldDescriptorProto'TYPE_SFIXED64+        maybeToEnum 17 = Prelude.Just FieldDescriptorProto'TYPE_SINT32+        maybeToEnum 18 = Prelude.Just FieldDescriptorProto'TYPE_SINT64+        maybeToEnum _ = Prelude.Nothing+        showEnum FieldDescriptorProto'TYPE_DOUBLE = "TYPE_DOUBLE"+        showEnum FieldDescriptorProto'TYPE_FLOAT = "TYPE_FLOAT"+        showEnum FieldDescriptorProto'TYPE_INT64 = "TYPE_INT64"+        showEnum FieldDescriptorProto'TYPE_UINT64 = "TYPE_UINT64"+        showEnum FieldDescriptorProto'TYPE_INT32 = "TYPE_INT32"+        showEnum FieldDescriptorProto'TYPE_FIXED64 = "TYPE_FIXED64"+        showEnum FieldDescriptorProto'TYPE_FIXED32 = "TYPE_FIXED32"+        showEnum FieldDescriptorProto'TYPE_BOOL = "TYPE_BOOL"+        showEnum FieldDescriptorProto'TYPE_STRING = "TYPE_STRING"+        showEnum FieldDescriptorProto'TYPE_GROUP = "TYPE_GROUP"+        showEnum FieldDescriptorProto'TYPE_MESSAGE = "TYPE_MESSAGE"+        showEnum FieldDescriptorProto'TYPE_BYTES = "TYPE_BYTES"+        showEnum FieldDescriptorProto'TYPE_UINT32 = "TYPE_UINT32"+        showEnum FieldDescriptorProto'TYPE_ENUM = "TYPE_ENUM"+        showEnum FieldDescriptorProto'TYPE_SFIXED32 = "TYPE_SFIXED32"+        showEnum FieldDescriptorProto'TYPE_SFIXED64 = "TYPE_SFIXED64"+        showEnum FieldDescriptorProto'TYPE_SINT32 = "TYPE_SINT32"+        showEnum FieldDescriptorProto'TYPE_SINT64 = "TYPE_SINT64"+        readEnum "TYPE_DOUBLE"+          = Prelude.Just FieldDescriptorProto'TYPE_DOUBLE+        readEnum "TYPE_FLOAT"+          = Prelude.Just FieldDescriptorProto'TYPE_FLOAT+        readEnum "TYPE_INT64"+          = Prelude.Just FieldDescriptorProto'TYPE_INT64+        readEnum "TYPE_UINT64"+          = Prelude.Just FieldDescriptorProto'TYPE_UINT64+        readEnum "TYPE_INT32"+          = Prelude.Just FieldDescriptorProto'TYPE_INT32+        readEnum "TYPE_FIXED64"+          = Prelude.Just FieldDescriptorProto'TYPE_FIXED64+        readEnum "TYPE_FIXED32"+          = Prelude.Just FieldDescriptorProto'TYPE_FIXED32+        readEnum "TYPE_BOOL" = Prelude.Just FieldDescriptorProto'TYPE_BOOL+        readEnum "TYPE_STRING"+          = Prelude.Just FieldDescriptorProto'TYPE_STRING+        readEnum "TYPE_GROUP"+          = Prelude.Just FieldDescriptorProto'TYPE_GROUP+        readEnum "TYPE_MESSAGE"+          = Prelude.Just FieldDescriptorProto'TYPE_MESSAGE+        readEnum "TYPE_BYTES"+          = Prelude.Just FieldDescriptorProto'TYPE_BYTES+        readEnum "TYPE_UINT32"+          = Prelude.Just FieldDescriptorProto'TYPE_UINT32+        readEnum "TYPE_ENUM" = Prelude.Just FieldDescriptorProto'TYPE_ENUM+        readEnum "TYPE_SFIXED32"+          = Prelude.Just FieldDescriptorProto'TYPE_SFIXED32+        readEnum "TYPE_SFIXED64"+          = Prelude.Just FieldDescriptorProto'TYPE_SFIXED64+        readEnum "TYPE_SINT32"+          = Prelude.Just FieldDescriptorProto'TYPE_SINT32+        readEnum "TYPE_SINT64"+          = Prelude.Just FieldDescriptorProto'TYPE_SINT64+        readEnum _ = Prelude.Nothing+instance Prelude.Enum FieldDescriptorProto'Type where+        toEnum k__+          = Prelude.maybe+              (Prelude.error+                 ((Prelude.++) "toEnum: unknown value for enum Type: "+                    (Prelude.show k__)))+              Prelude.id+              (Data.ProtoLens.maybeToEnum k__)+        fromEnum FieldDescriptorProto'TYPE_DOUBLE = 1+        fromEnum FieldDescriptorProto'TYPE_FLOAT = 2+        fromEnum FieldDescriptorProto'TYPE_INT64 = 3+        fromEnum FieldDescriptorProto'TYPE_UINT64 = 4+        fromEnum FieldDescriptorProto'TYPE_INT32 = 5+        fromEnum FieldDescriptorProto'TYPE_FIXED64 = 6+        fromEnum FieldDescriptorProto'TYPE_FIXED32 = 7+        fromEnum FieldDescriptorProto'TYPE_BOOL = 8+        fromEnum FieldDescriptorProto'TYPE_STRING = 9+        fromEnum FieldDescriptorProto'TYPE_GROUP = 10+        fromEnum FieldDescriptorProto'TYPE_MESSAGE = 11+        fromEnum FieldDescriptorProto'TYPE_BYTES = 12+        fromEnum FieldDescriptorProto'TYPE_UINT32 = 13+        fromEnum FieldDescriptorProto'TYPE_ENUM = 14+        fromEnum FieldDescriptorProto'TYPE_SFIXED32 = 15+        fromEnum FieldDescriptorProto'TYPE_SFIXED64 = 16+        fromEnum FieldDescriptorProto'TYPE_SINT32 = 17+        fromEnum FieldDescriptorProto'TYPE_SINT64 = 18+        succ FieldDescriptorProto'TYPE_SINT64+          = Prelude.error+              "FieldDescriptorProto'Type.succ: bad argument FieldDescriptorProto'TYPE_SINT64. This value would be out of bounds."+        succ FieldDescriptorProto'TYPE_DOUBLE+          = FieldDescriptorProto'TYPE_FLOAT+        succ FieldDescriptorProto'TYPE_FLOAT+          = FieldDescriptorProto'TYPE_INT64+        succ FieldDescriptorProto'TYPE_INT64+          = FieldDescriptorProto'TYPE_UINT64+        succ FieldDescriptorProto'TYPE_UINT64+          = FieldDescriptorProto'TYPE_INT32+        succ FieldDescriptorProto'TYPE_INT32+          = FieldDescriptorProto'TYPE_FIXED64+        succ FieldDescriptorProto'TYPE_FIXED64+          = FieldDescriptorProto'TYPE_FIXED32+        succ FieldDescriptorProto'TYPE_FIXED32+          = FieldDescriptorProto'TYPE_BOOL+        succ FieldDescriptorProto'TYPE_BOOL+          = FieldDescriptorProto'TYPE_STRING+        succ FieldDescriptorProto'TYPE_STRING+          = FieldDescriptorProto'TYPE_GROUP+        succ FieldDescriptorProto'TYPE_GROUP+          = FieldDescriptorProto'TYPE_MESSAGE+        succ FieldDescriptorProto'TYPE_MESSAGE+          = FieldDescriptorProto'TYPE_BYTES+        succ FieldDescriptorProto'TYPE_BYTES+          = FieldDescriptorProto'TYPE_UINT32+        succ FieldDescriptorProto'TYPE_UINT32+          = FieldDescriptorProto'TYPE_ENUM+        succ FieldDescriptorProto'TYPE_ENUM+          = FieldDescriptorProto'TYPE_SFIXED32+        succ FieldDescriptorProto'TYPE_SFIXED32+          = FieldDescriptorProto'TYPE_SFIXED64+        succ FieldDescriptorProto'TYPE_SFIXED64+          = FieldDescriptorProto'TYPE_SINT32+        succ FieldDescriptorProto'TYPE_SINT32+          = FieldDescriptorProto'TYPE_SINT64+        pred FieldDescriptorProto'TYPE_DOUBLE+          = Prelude.error+              "FieldDescriptorProto'Type.pred: bad argument FieldDescriptorProto'TYPE_DOUBLE. This value would be out of bounds."+        pred FieldDescriptorProto'TYPE_FLOAT+          = FieldDescriptorProto'TYPE_DOUBLE+        pred FieldDescriptorProto'TYPE_INT64+          = FieldDescriptorProto'TYPE_FLOAT+        pred FieldDescriptorProto'TYPE_UINT64+          = FieldDescriptorProto'TYPE_INT64+        pred FieldDescriptorProto'TYPE_INT32+          = FieldDescriptorProto'TYPE_UINT64+        pred FieldDescriptorProto'TYPE_FIXED64+          = FieldDescriptorProto'TYPE_INT32+        pred FieldDescriptorProto'TYPE_FIXED32+          = FieldDescriptorProto'TYPE_FIXED64+        pred FieldDescriptorProto'TYPE_BOOL+          = FieldDescriptorProto'TYPE_FIXED32+        pred FieldDescriptorProto'TYPE_STRING+          = FieldDescriptorProto'TYPE_BOOL+        pred FieldDescriptorProto'TYPE_GROUP+          = FieldDescriptorProto'TYPE_STRING+        pred FieldDescriptorProto'TYPE_MESSAGE+          = FieldDescriptorProto'TYPE_GROUP+        pred FieldDescriptorProto'TYPE_BYTES+          = FieldDescriptorProto'TYPE_MESSAGE+        pred FieldDescriptorProto'TYPE_UINT32+          = FieldDescriptorProto'TYPE_BYTES+        pred FieldDescriptorProto'TYPE_ENUM+          = FieldDescriptorProto'TYPE_UINT32+        pred FieldDescriptorProto'TYPE_SFIXED32+          = FieldDescriptorProto'TYPE_ENUM+        pred FieldDescriptorProto'TYPE_SFIXED64+          = FieldDescriptorProto'TYPE_SFIXED32+        pred FieldDescriptorProto'TYPE_SINT32+          = FieldDescriptorProto'TYPE_SFIXED64+        pred FieldDescriptorProto'TYPE_SINT64+          = FieldDescriptorProto'TYPE_SINT32+        enumFrom = Data.ProtoLens.Message.Enum.messageEnumFrom+        enumFromTo = Data.ProtoLens.Message.Enum.messageEnumFromTo+        enumFromThen = Data.ProtoLens.Message.Enum.messageEnumFromThen+        enumFromThenTo = Data.ProtoLens.Message.Enum.messageEnumFromThenTo+instance Prelude.Bounded FieldDescriptorProto'Type where+        minBound = FieldDescriptorProto'TYPE_DOUBLE+        maxBound = FieldDescriptorProto'TYPE_SINT64+{- | Fields :++    * 'Proto.Google.Protobuf.Descriptor_Fields.ctype' @:: Lens' FieldOptions FieldOptions'CType@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'ctype' @:: Lens' FieldOptions (Prelude.Maybe FieldOptions'CType)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.packed' @:: Lens' FieldOptions Prelude.Bool@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'packed' @:: Lens' FieldOptions (Prelude.Maybe Prelude.Bool)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.jstype' @:: Lens' FieldOptions FieldOptions'JSType@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'jstype' @:: Lens' FieldOptions (Prelude.Maybe FieldOptions'JSType)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.lazy' @:: Lens' FieldOptions Prelude.Bool@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'lazy' @:: Lens' FieldOptions (Prelude.Maybe Prelude.Bool)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.deprecated' @:: Lens' FieldOptions Prelude.Bool@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'deprecated' @:: Lens' FieldOptions (Prelude.Maybe Prelude.Bool)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.weak' @:: Lens' FieldOptions Prelude.Bool@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'weak' @:: Lens' FieldOptions (Prelude.Maybe Prelude.Bool)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.uninterpretedOption' @:: Lens' FieldOptions [UninterpretedOption]@+ -}+data FieldOptions = FieldOptions{_FieldOptions'ctype ::+                                 !(Prelude.Maybe FieldOptions'CType),+                                 _FieldOptions'packed :: !(Prelude.Maybe Prelude.Bool),+                                 _FieldOptions'jstype :: !(Prelude.Maybe FieldOptions'JSType),+                                 _FieldOptions'lazy :: !(Prelude.Maybe Prelude.Bool),+                                 _FieldOptions'deprecated :: !(Prelude.Maybe Prelude.Bool),+                                 _FieldOptions'weak :: !(Prelude.Maybe Prelude.Bool),+                                 _FieldOptions'uninterpretedOption :: ![UninterpretedOption],+                                 _FieldOptions'_unknownFields :: !Data.ProtoLens.FieldSet}+                  deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)+instance (Lens.Labels.HasLens' f FieldOptions x a, a ~ b) =>+         Lens.Labels.HasLens f FieldOptions FieldOptions x a b+         where+        lensOf = Lens.Labels.lensOf'+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FieldOptions "ctype" (FieldOptions'CType)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FieldOptions'ctype+                 (\ x__ y__ -> x__{_FieldOptions'ctype = y__}))+              (Data.ProtoLens.maybeLens FieldOptions'STRING)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FieldOptions "maybe'ctype"+           (Prelude.Maybe FieldOptions'CType)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FieldOptions'ctype+                 (\ x__ y__ -> x__{_FieldOptions'ctype = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FieldOptions "packed" (Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FieldOptions'packed+                 (\ x__ y__ -> x__{_FieldOptions'packed = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FieldOptions "maybe'packed"+           (Prelude.Maybe Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FieldOptions'packed+                 (\ x__ y__ -> x__{_FieldOptions'packed = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FieldOptions "jstype" (FieldOptions'JSType)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FieldOptions'jstype+                 (\ x__ y__ -> x__{_FieldOptions'jstype = y__}))+              (Data.ProtoLens.maybeLens FieldOptions'JS_NORMAL)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FieldOptions "maybe'jstype"+           (Prelude.Maybe FieldOptions'JSType)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FieldOptions'jstype+                 (\ x__ y__ -> x__{_FieldOptions'jstype = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FieldOptions "lazy" (Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FieldOptions'lazy+                 (\ x__ y__ -> x__{_FieldOptions'lazy = y__}))+              (Data.ProtoLens.maybeLens Prelude.False)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FieldOptions "maybe'lazy"+           (Prelude.Maybe Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FieldOptions'lazy+                 (\ x__ y__ -> x__{_FieldOptions'lazy = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FieldOptions "deprecated" (Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FieldOptions'deprecated+                 (\ x__ y__ -> x__{_FieldOptions'deprecated = y__}))+              (Data.ProtoLens.maybeLens Prelude.False)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FieldOptions "maybe'deprecated"+           (Prelude.Maybe Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FieldOptions'deprecated+                 (\ x__ y__ -> x__{_FieldOptions'deprecated = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FieldOptions "weak" (Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FieldOptions'weak+                 (\ x__ y__ -> x__{_FieldOptions'weak = y__}))+              (Data.ProtoLens.maybeLens Prelude.False)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FieldOptions "maybe'weak"+           (Prelude.Maybe Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FieldOptions'weak+                 (\ x__ y__ -> x__{_FieldOptions'weak = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FieldOptions "uninterpretedOption"+           ([UninterpretedOption])+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FieldOptions'uninterpretedOption+                 (\ x__ y__ -> x__{_FieldOptions'uninterpretedOption = y__}))+              Prelude.id+instance Data.Default.Class.Default FieldOptions where+        def+          = FieldOptions{_FieldOptions'ctype = Prelude.Nothing,+                         _FieldOptions'packed = Prelude.Nothing,+                         _FieldOptions'jstype = Prelude.Nothing,+                         _FieldOptions'lazy = Prelude.Nothing,+                         _FieldOptions'deprecated = Prelude.Nothing,+                         _FieldOptions'weak = Prelude.Nothing,+                         _FieldOptions'uninterpretedOption = [],+                         _FieldOptions'_unknownFields = ([])}+instance Data.ProtoLens.Message FieldOptions where+        messageName _ = Data.Text.pack "google.protobuf.FieldOptions"+        fieldsByTag+          = let ctype__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "ctype"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField ::+                         Data.ProtoLens.FieldTypeDescriptor FieldOptions'CType)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'ctype")))+                      :: Data.ProtoLens.FieldDescriptor FieldOptions+                packed__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "packed"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'packed")))+                      :: Data.ProtoLens.FieldDescriptor FieldOptions+                jstype__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "jstype"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField ::+                         Data.ProtoLens.FieldTypeDescriptor FieldOptions'JSType)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'jstype")))+                      :: Data.ProtoLens.FieldDescriptor FieldOptions+                lazy__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "lazy"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'lazy")))+                      :: Data.ProtoLens.FieldDescriptor FieldOptions+                deprecated__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "deprecated"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'deprecated")))+                      :: Data.ProtoLens.FieldDescriptor FieldOptions+                weak__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "weak"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'weak")))+                      :: Data.ProtoLens.FieldDescriptor FieldOptions+                uninterpretedOption__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "uninterpreted_option"+                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                         Data.ProtoLens.FieldTypeDescriptor UninterpretedOption)+                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) ::+                               (Lens.Labels.Proxy#) "uninterpretedOption")))+                      :: Data.ProtoLens.FieldDescriptor FieldOptions+              in+              Data.Map.fromList+                [(Data.ProtoLens.Tag 1, ctype__field_descriptor),+                 (Data.ProtoLens.Tag 2, packed__field_descriptor),+                 (Data.ProtoLens.Tag 6, jstype__field_descriptor),+                 (Data.ProtoLens.Tag 5, lazy__field_descriptor),+                 (Data.ProtoLens.Tag 3, deprecated__field_descriptor),+                 (Data.ProtoLens.Tag 10, weak__field_descriptor),+                 (Data.ProtoLens.Tag 999, uninterpretedOption__field_descriptor)]+        unknownFields+          = Lens.Family2.Unchecked.lens _FieldOptions'_unknownFields+              (\ x__ y__ -> x__{_FieldOptions'_unknownFields = y__})+data FieldOptions'CType = FieldOptions'STRING+                        | FieldOptions'CORD+                        | FieldOptions'STRING_PIECE+                        deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)+instance Data.Default.Class.Default FieldOptions'CType where+        def = FieldOptions'STRING+instance Data.ProtoLens.FieldDefault FieldOptions'CType where+        fieldDefault = FieldOptions'STRING+instance Data.ProtoLens.MessageEnum FieldOptions'CType where+        maybeToEnum 0 = Prelude.Just FieldOptions'STRING+        maybeToEnum 1 = Prelude.Just FieldOptions'CORD+        maybeToEnum 2 = Prelude.Just FieldOptions'STRING_PIECE+        maybeToEnum _ = Prelude.Nothing+        showEnum FieldOptions'STRING = "STRING"+        showEnum FieldOptions'CORD = "CORD"+        showEnum FieldOptions'STRING_PIECE = "STRING_PIECE"+        readEnum "STRING" = Prelude.Just FieldOptions'STRING+        readEnum "CORD" = Prelude.Just FieldOptions'CORD+        readEnum "STRING_PIECE" = Prelude.Just FieldOptions'STRING_PIECE+        readEnum _ = Prelude.Nothing+instance Prelude.Enum FieldOptions'CType where+        toEnum k__+          = Prelude.maybe+              (Prelude.error+                 ((Prelude.++) "toEnum: unknown value for enum CType: "+                    (Prelude.show k__)))+              Prelude.id+              (Data.ProtoLens.maybeToEnum k__)+        fromEnum FieldOptions'STRING = 0+        fromEnum FieldOptions'CORD = 1+        fromEnum FieldOptions'STRING_PIECE = 2+        succ FieldOptions'STRING_PIECE+          = Prelude.error+              "FieldOptions'CType.succ: bad argument FieldOptions'STRING_PIECE. This value would be out of bounds."+        succ FieldOptions'STRING = FieldOptions'CORD+        succ FieldOptions'CORD = FieldOptions'STRING_PIECE+        pred FieldOptions'STRING+          = Prelude.error+              "FieldOptions'CType.pred: bad argument FieldOptions'STRING. This value would be out of bounds."+        pred FieldOptions'CORD = FieldOptions'STRING+        pred FieldOptions'STRING_PIECE = FieldOptions'CORD+        enumFrom = Data.ProtoLens.Message.Enum.messageEnumFrom+        enumFromTo = Data.ProtoLens.Message.Enum.messageEnumFromTo+        enumFromThen = Data.ProtoLens.Message.Enum.messageEnumFromThen+        enumFromThenTo = Data.ProtoLens.Message.Enum.messageEnumFromThenTo+instance Prelude.Bounded FieldOptions'CType where+        minBound = FieldOptions'STRING+        maxBound = FieldOptions'STRING_PIECE+data FieldOptions'JSType = FieldOptions'JS_NORMAL+                         | FieldOptions'JS_STRING+                         | FieldOptions'JS_NUMBER+                         deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)+instance Data.Default.Class.Default FieldOptions'JSType where+        def = FieldOptions'JS_NORMAL+instance Data.ProtoLens.FieldDefault FieldOptions'JSType where+        fieldDefault = FieldOptions'JS_NORMAL+instance Data.ProtoLens.MessageEnum FieldOptions'JSType where+        maybeToEnum 0 = Prelude.Just FieldOptions'JS_NORMAL+        maybeToEnum 1 = Prelude.Just FieldOptions'JS_STRING+        maybeToEnum 2 = Prelude.Just FieldOptions'JS_NUMBER+        maybeToEnum _ = Prelude.Nothing+        showEnum FieldOptions'JS_NORMAL = "JS_NORMAL"+        showEnum FieldOptions'JS_STRING = "JS_STRING"+        showEnum FieldOptions'JS_NUMBER = "JS_NUMBER"+        readEnum "JS_NORMAL" = Prelude.Just FieldOptions'JS_NORMAL+        readEnum "JS_STRING" = Prelude.Just FieldOptions'JS_STRING+        readEnum "JS_NUMBER" = Prelude.Just FieldOptions'JS_NUMBER+        readEnum _ = Prelude.Nothing+instance Prelude.Enum FieldOptions'JSType where+        toEnum k__+          = Prelude.maybe+              (Prelude.error+                 ((Prelude.++) "toEnum: unknown value for enum JSType: "+                    (Prelude.show k__)))+              Prelude.id+              (Data.ProtoLens.maybeToEnum k__)+        fromEnum FieldOptions'JS_NORMAL = 0+        fromEnum FieldOptions'JS_STRING = 1+        fromEnum FieldOptions'JS_NUMBER = 2+        succ FieldOptions'JS_NUMBER+          = Prelude.error+              "FieldOptions'JSType.succ: bad argument FieldOptions'JS_NUMBER. This value would be out of bounds."+        succ FieldOptions'JS_NORMAL = FieldOptions'JS_STRING+        succ FieldOptions'JS_STRING = FieldOptions'JS_NUMBER+        pred FieldOptions'JS_NORMAL+          = Prelude.error+              "FieldOptions'JSType.pred: bad argument FieldOptions'JS_NORMAL. This value would be out of bounds."+        pred FieldOptions'JS_STRING = FieldOptions'JS_NORMAL+        pred FieldOptions'JS_NUMBER = FieldOptions'JS_STRING+        enumFrom = Data.ProtoLens.Message.Enum.messageEnumFrom+        enumFromTo = Data.ProtoLens.Message.Enum.messageEnumFromTo+        enumFromThen = Data.ProtoLens.Message.Enum.messageEnumFromThen+        enumFromThenTo = Data.ProtoLens.Message.Enum.messageEnumFromThenTo+instance Prelude.Bounded FieldOptions'JSType where+        minBound = FieldOptions'JS_NORMAL+        maxBound = FieldOptions'JS_NUMBER+{- | Fields :++    * 'Proto.Google.Protobuf.Descriptor_Fields.name' @:: Lens' FileDescriptorProto Data.Text.Text@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'name' @:: Lens' FileDescriptorProto (Prelude.Maybe Data.Text.Text)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.package' @:: Lens' FileDescriptorProto Data.Text.Text@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'package' @:: Lens' FileDescriptorProto (Prelude.Maybe Data.Text.Text)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.dependency' @:: Lens' FileDescriptorProto [Data.Text.Text]@+    * 'Proto.Google.Protobuf.Descriptor_Fields.publicDependency' @:: Lens' FileDescriptorProto [Data.Int.Int32]@+    * 'Proto.Google.Protobuf.Descriptor_Fields.weakDependency' @:: Lens' FileDescriptorProto [Data.Int.Int32]@+    * 'Proto.Google.Protobuf.Descriptor_Fields.messageType' @:: Lens' FileDescriptorProto [DescriptorProto]@+    * 'Proto.Google.Protobuf.Descriptor_Fields.enumType' @:: Lens' FileDescriptorProto [EnumDescriptorProto]@+    * 'Proto.Google.Protobuf.Descriptor_Fields.service' @:: Lens' FileDescriptorProto [ServiceDescriptorProto]@+    * 'Proto.Google.Protobuf.Descriptor_Fields.extension' @:: Lens' FileDescriptorProto [FieldDescriptorProto]@+    * 'Proto.Google.Protobuf.Descriptor_Fields.options' @:: Lens' FileDescriptorProto FileOptions@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'options' @:: Lens' FileDescriptorProto (Prelude.Maybe FileOptions)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.sourceCodeInfo' @:: Lens' FileDescriptorProto SourceCodeInfo@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'sourceCodeInfo' @:: Lens' FileDescriptorProto (Prelude.Maybe SourceCodeInfo)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.syntax' @:: Lens' FileDescriptorProto Data.Text.Text@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'syntax' @:: Lens' FileDescriptorProto (Prelude.Maybe Data.Text.Text)@+ -}+data FileDescriptorProto = FileDescriptorProto{_FileDescriptorProto'name+                                               :: !(Prelude.Maybe Data.Text.Text),+                                               _FileDescriptorProto'package ::+                                               !(Prelude.Maybe Data.Text.Text),+                                               _FileDescriptorProto'dependency :: ![Data.Text.Text],+                                               _FileDescriptorProto'publicDependency ::+                                               ![Data.Int.Int32],+                                               _FileDescriptorProto'weakDependency ::+                                               ![Data.Int.Int32],+                                               _FileDescriptorProto'messageType ::+                                               ![DescriptorProto],+                                               _FileDescriptorProto'enumType ::+                                               ![EnumDescriptorProto],+                                               _FileDescriptorProto'service ::+                                               ![ServiceDescriptorProto],+                                               _FileDescriptorProto'extension ::+                                               ![FieldDescriptorProto],+                                               _FileDescriptorProto'options ::+                                               !(Prelude.Maybe FileOptions),+                                               _FileDescriptorProto'sourceCodeInfo ::+                                               !(Prelude.Maybe SourceCodeInfo),+                                               _FileDescriptorProto'syntax ::+                                               !(Prelude.Maybe Data.Text.Text),+                                               _FileDescriptorProto'_unknownFields ::+                                               !Data.ProtoLens.FieldSet}+                         deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)+instance (Lens.Labels.HasLens' f FileDescriptorProto x a, a ~ b) =>+         Lens.Labels.HasLens f FileDescriptorProto FileDescriptorProto x a b+         where+        lensOf = Lens.Labels.lensOf'+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileDescriptorProto "name" (Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileDescriptorProto'name+                 (\ x__ y__ -> x__{_FileDescriptorProto'name = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileDescriptorProto "maybe'name"+           (Prelude.Maybe Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileDescriptorProto'name+                 (\ x__ y__ -> x__{_FileDescriptorProto'name = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileDescriptorProto "package"+           (Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileDescriptorProto'package+                 (\ x__ y__ -> x__{_FileDescriptorProto'package = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileDescriptorProto "maybe'package"+           (Prelude.Maybe Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileDescriptorProto'package+                 (\ x__ y__ -> x__{_FileDescriptorProto'package = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileDescriptorProto "dependency"+           ([Data.Text.Text])+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileDescriptorProto'dependency+                 (\ x__ y__ -> x__{_FileDescriptorProto'dependency = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileDescriptorProto "publicDependency"+           ([Data.Int.Int32])+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileDescriptorProto'publicDependency+                 (\ x__ y__ -> x__{_FileDescriptorProto'publicDependency = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileDescriptorProto "weakDependency"+           ([Data.Int.Int32])+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileDescriptorProto'weakDependency+                 (\ x__ y__ -> x__{_FileDescriptorProto'weakDependency = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileDescriptorProto "messageType"+           ([DescriptorProto])+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileDescriptorProto'messageType+                 (\ x__ y__ -> x__{_FileDescriptorProto'messageType = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileDescriptorProto "enumType"+           ([EnumDescriptorProto])+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileDescriptorProto'enumType+                 (\ x__ y__ -> x__{_FileDescriptorProto'enumType = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileDescriptorProto "service"+           ([ServiceDescriptorProto])+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileDescriptorProto'service+                 (\ x__ y__ -> x__{_FileDescriptorProto'service = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileDescriptorProto "extension"+           ([FieldDescriptorProto])+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileDescriptorProto'extension+                 (\ x__ y__ -> x__{_FileDescriptorProto'extension = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileDescriptorProto "options" (FileOptions)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileDescriptorProto'options+                 (\ x__ y__ -> x__{_FileDescriptorProto'options = y__}))+              (Data.ProtoLens.maybeLens Data.Default.Class.def)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileDescriptorProto "maybe'options"+           (Prelude.Maybe FileOptions)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileDescriptorProto'options+                 (\ x__ y__ -> x__{_FileDescriptorProto'options = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileDescriptorProto "sourceCodeInfo"+           (SourceCodeInfo)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileDescriptorProto'sourceCodeInfo+                 (\ x__ y__ -> x__{_FileDescriptorProto'sourceCodeInfo = y__}))+              (Data.ProtoLens.maybeLens Data.Default.Class.def)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileDescriptorProto "maybe'sourceCodeInfo"+           (Prelude.Maybe SourceCodeInfo)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileDescriptorProto'sourceCodeInfo+                 (\ x__ y__ -> x__{_FileDescriptorProto'sourceCodeInfo = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileDescriptorProto "syntax"+           (Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileDescriptorProto'syntax+                 (\ x__ y__ -> x__{_FileDescriptorProto'syntax = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileDescriptorProto "maybe'syntax"+           (Prelude.Maybe Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileDescriptorProto'syntax+                 (\ x__ y__ -> x__{_FileDescriptorProto'syntax = y__}))+              Prelude.id+instance Data.Default.Class.Default FileDescriptorProto where+        def+          = FileDescriptorProto{_FileDescriptorProto'name = Prelude.Nothing,+                                _FileDescriptorProto'package = Prelude.Nothing,+                                _FileDescriptorProto'dependency = [],+                                _FileDescriptorProto'publicDependency = [],+                                _FileDescriptorProto'weakDependency = [],+                                _FileDescriptorProto'messageType = [],+                                _FileDescriptorProto'enumType = [],+                                _FileDescriptorProto'service = [],+                                _FileDescriptorProto'extension = [],+                                _FileDescriptorProto'options = Prelude.Nothing,+                                _FileDescriptorProto'sourceCodeInfo = Prelude.Nothing,+                                _FileDescriptorProto'syntax = Prelude.Nothing,+                                _FileDescriptorProto'_unknownFields = ([])}+instance Data.ProtoLens.Message FileDescriptorProto where+        messageName _+          = Data.Text.pack "google.protobuf.FileDescriptorProto"+        fieldsByTag+          = let name__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "name"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'name")))+                      :: Data.ProtoLens.FieldDescriptor FileDescriptorProto+                package__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "package"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'package")))+                      :: Data.ProtoLens.FieldDescriptor FileDescriptorProto+                dependency__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "dependency"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "dependency")))+                      :: Data.ProtoLens.FieldDescriptor FileDescriptorProto+                publicDependency__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "public_dependency"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)+                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "publicDependency")))+                      :: Data.ProtoLens.FieldDescriptor FileDescriptorProto+                weakDependency__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "weak_dependency"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)+                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "weakDependency")))+                      :: Data.ProtoLens.FieldDescriptor FileDescriptorProto+                messageType__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "message_type"+                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                         Data.ProtoLens.FieldTypeDescriptor DescriptorProto)+                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "messageType")))+                      :: Data.ProtoLens.FieldDescriptor FileDescriptorProto+                enumType__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "enum_type"+                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                         Data.ProtoLens.FieldTypeDescriptor EnumDescriptorProto)+                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "enumType")))+                      :: Data.ProtoLens.FieldDescriptor FileDescriptorProto+                service__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "service"+                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                         Data.ProtoLens.FieldTypeDescriptor ServiceDescriptorProto)+                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "service")))+                      :: Data.ProtoLens.FieldDescriptor FileDescriptorProto+                extension__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "extension"+                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                         Data.ProtoLens.FieldTypeDescriptor FieldDescriptorProto)+                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "extension")))+                      :: Data.ProtoLens.FieldDescriptor FileDescriptorProto+                options__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "options"+                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                         Data.ProtoLens.FieldTypeDescriptor FileOptions)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'options")))+                      :: Data.ProtoLens.FieldDescriptor FileDescriptorProto+                sourceCodeInfo__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "source_code_info"+                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                         Data.ProtoLens.FieldTypeDescriptor SourceCodeInfo)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) ::+                               (Lens.Labels.Proxy#) "maybe'sourceCodeInfo")))+                      :: Data.ProtoLens.FieldDescriptor FileDescriptorProto+                syntax__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "syntax"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'syntax")))+                      :: Data.ProtoLens.FieldDescriptor FileDescriptorProto+              in+              Data.Map.fromList+                [(Data.ProtoLens.Tag 1, name__field_descriptor),+                 (Data.ProtoLens.Tag 2, package__field_descriptor),+                 (Data.ProtoLens.Tag 3, dependency__field_descriptor),+                 (Data.ProtoLens.Tag 10, publicDependency__field_descriptor),+                 (Data.ProtoLens.Tag 11, weakDependency__field_descriptor),+                 (Data.ProtoLens.Tag 4, messageType__field_descriptor),+                 (Data.ProtoLens.Tag 5, enumType__field_descriptor),+                 (Data.ProtoLens.Tag 6, service__field_descriptor),+                 (Data.ProtoLens.Tag 7, extension__field_descriptor),+                 (Data.ProtoLens.Tag 8, options__field_descriptor),+                 (Data.ProtoLens.Tag 9, sourceCodeInfo__field_descriptor),+                 (Data.ProtoLens.Tag 12, syntax__field_descriptor)]+        unknownFields+          = Lens.Family2.Unchecked.lens _FileDescriptorProto'_unknownFields+              (\ x__ y__ -> x__{_FileDescriptorProto'_unknownFields = y__})+{- | Fields :++    * 'Proto.Google.Protobuf.Descriptor_Fields.file' @:: Lens' FileDescriptorSet [FileDescriptorProto]@+ -}+data FileDescriptorSet = FileDescriptorSet{_FileDescriptorSet'file+                                           :: ![FileDescriptorProto],+                                           _FileDescriptorSet'_unknownFields ::+                                           !Data.ProtoLens.FieldSet}+                       deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)+instance (Lens.Labels.HasLens' f FileDescriptorSet x a, a ~ b) =>+         Lens.Labels.HasLens f FileDescriptorSet FileDescriptorSet x a b+         where+        lensOf = Lens.Labels.lensOf'+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileDescriptorSet "file"+           ([FileDescriptorProto])+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileDescriptorSet'file+                 (\ x__ y__ -> x__{_FileDescriptorSet'file = y__}))+              Prelude.id+instance Data.Default.Class.Default FileDescriptorSet where+        def+          = FileDescriptorSet{_FileDescriptorSet'file = [],+                              _FileDescriptorSet'_unknownFields = ([])}+instance Data.ProtoLens.Message FileDescriptorSet where+        messageName _ = Data.Text.pack "google.protobuf.FileDescriptorSet"+        fieldsByTag+          = let file__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "file"+                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                         Data.ProtoLens.FieldTypeDescriptor FileDescriptorProto)+                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "file")))+                      :: Data.ProtoLens.FieldDescriptor FileDescriptorSet+              in+              Data.Map.fromList [(Data.ProtoLens.Tag 1, file__field_descriptor)]+        unknownFields+          = Lens.Family2.Unchecked.lens _FileDescriptorSet'_unknownFields+              (\ x__ y__ -> x__{_FileDescriptorSet'_unknownFields = y__})+{- | Fields :++    * 'Proto.Google.Protobuf.Descriptor_Fields.javaPackage' @:: Lens' FileOptions Data.Text.Text@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'javaPackage' @:: Lens' FileOptions (Prelude.Maybe Data.Text.Text)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.javaOuterClassname' @:: Lens' FileOptions Data.Text.Text@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'javaOuterClassname' @:: Lens' FileOptions (Prelude.Maybe Data.Text.Text)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.javaMultipleFiles' @:: Lens' FileOptions Prelude.Bool@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'javaMultipleFiles' @:: Lens' FileOptions (Prelude.Maybe Prelude.Bool)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.javaGenerateEqualsAndHash' @:: Lens' FileOptions Prelude.Bool@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'javaGenerateEqualsAndHash' @:: Lens' FileOptions (Prelude.Maybe Prelude.Bool)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.javaStringCheckUtf8' @:: Lens' FileOptions Prelude.Bool@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'javaStringCheckUtf8' @:: Lens' FileOptions (Prelude.Maybe Prelude.Bool)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.optimizeFor' @:: Lens' FileOptions FileOptions'OptimizeMode@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'optimizeFor' @:: Lens' FileOptions (Prelude.Maybe FileOptions'OptimizeMode)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.goPackage' @:: Lens' FileOptions Data.Text.Text@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'goPackage' @:: Lens' FileOptions (Prelude.Maybe Data.Text.Text)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.ccGenericServices' @:: Lens' FileOptions Prelude.Bool@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'ccGenericServices' @:: Lens' FileOptions (Prelude.Maybe Prelude.Bool)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.javaGenericServices' @:: Lens' FileOptions Prelude.Bool@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'javaGenericServices' @:: Lens' FileOptions (Prelude.Maybe Prelude.Bool)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.pyGenericServices' @:: Lens' FileOptions Prelude.Bool@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'pyGenericServices' @:: Lens' FileOptions (Prelude.Maybe Prelude.Bool)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.deprecated' @:: Lens' FileOptions Prelude.Bool@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'deprecated' @:: Lens' FileOptions (Prelude.Maybe Prelude.Bool)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.ccEnableArenas' @:: Lens' FileOptions Prelude.Bool@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'ccEnableArenas' @:: Lens' FileOptions (Prelude.Maybe Prelude.Bool)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.objcClassPrefix' @:: Lens' FileOptions Data.Text.Text@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'objcClassPrefix' @:: Lens' FileOptions (Prelude.Maybe Data.Text.Text)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.csharpNamespace' @:: Lens' FileOptions Data.Text.Text@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'csharpNamespace' @:: Lens' FileOptions (Prelude.Maybe Data.Text.Text)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.uninterpretedOption' @:: Lens' FileOptions [UninterpretedOption]@+ -}+data FileOptions = FileOptions{_FileOptions'javaPackage ::+                               !(Prelude.Maybe Data.Text.Text),+                               _FileOptions'javaOuterClassname :: !(Prelude.Maybe Data.Text.Text),+                               _FileOptions'javaMultipleFiles :: !(Prelude.Maybe Prelude.Bool),+                               _FileOptions'javaGenerateEqualsAndHash ::+                               !(Prelude.Maybe Prelude.Bool),+                               _FileOptions'javaStringCheckUtf8 :: !(Prelude.Maybe Prelude.Bool),+                               _FileOptions'optimizeFor ::+                               !(Prelude.Maybe FileOptions'OptimizeMode),+                               _FileOptions'goPackage :: !(Prelude.Maybe Data.Text.Text),+                               _FileOptions'ccGenericServices :: !(Prelude.Maybe Prelude.Bool),+                               _FileOptions'javaGenericServices :: !(Prelude.Maybe Prelude.Bool),+                               _FileOptions'pyGenericServices :: !(Prelude.Maybe Prelude.Bool),+                               _FileOptions'deprecated :: !(Prelude.Maybe Prelude.Bool),+                               _FileOptions'ccEnableArenas :: !(Prelude.Maybe Prelude.Bool),+                               _FileOptions'objcClassPrefix :: !(Prelude.Maybe Data.Text.Text),+                               _FileOptions'csharpNamespace :: !(Prelude.Maybe Data.Text.Text),+                               _FileOptions'uninterpretedOption :: ![UninterpretedOption],+                               _FileOptions'_unknownFields :: !Data.ProtoLens.FieldSet}+                 deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)+instance (Lens.Labels.HasLens' f FileOptions x a, a ~ b) =>+         Lens.Labels.HasLens f FileOptions FileOptions x a b+         where+        lensOf = Lens.Labels.lensOf'+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileOptions "javaPackage" (Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileOptions'javaPackage+                 (\ x__ y__ -> x__{_FileOptions'javaPackage = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileOptions "maybe'javaPackage"+           (Prelude.Maybe Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileOptions'javaPackage+                 (\ x__ y__ -> x__{_FileOptions'javaPackage = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileOptions "javaOuterClassname"+           (Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileOptions'javaOuterClassname+                 (\ x__ y__ -> x__{_FileOptions'javaOuterClassname = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileOptions "maybe'javaOuterClassname"+           (Prelude.Maybe Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileOptions'javaOuterClassname+                 (\ x__ y__ -> x__{_FileOptions'javaOuterClassname = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileOptions "javaMultipleFiles"+           (Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileOptions'javaMultipleFiles+                 (\ x__ y__ -> x__{_FileOptions'javaMultipleFiles = y__}))+              (Data.ProtoLens.maybeLens Prelude.False)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileOptions "maybe'javaMultipleFiles"+           (Prelude.Maybe Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileOptions'javaMultipleFiles+                 (\ x__ y__ -> x__{_FileOptions'javaMultipleFiles = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileOptions "javaGenerateEqualsAndHash"+           (Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileOptions'javaGenerateEqualsAndHash+                 (\ x__ y__ -> x__{_FileOptions'javaGenerateEqualsAndHash = y__}))+              (Data.ProtoLens.maybeLens Prelude.False)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileOptions+           "maybe'javaGenerateEqualsAndHash"+           (Prelude.Maybe Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileOptions'javaGenerateEqualsAndHash+                 (\ x__ y__ -> x__{_FileOptions'javaGenerateEqualsAndHash = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileOptions "javaStringCheckUtf8"+           (Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileOptions'javaStringCheckUtf8+                 (\ x__ y__ -> x__{_FileOptions'javaStringCheckUtf8 = y__}))+              (Data.ProtoLens.maybeLens Prelude.False)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileOptions "maybe'javaStringCheckUtf8"+           (Prelude.Maybe Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileOptions'javaStringCheckUtf8+                 (\ x__ y__ -> x__{_FileOptions'javaStringCheckUtf8 = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileOptions "optimizeFor"+           (FileOptions'OptimizeMode)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileOptions'optimizeFor+                 (\ x__ y__ -> x__{_FileOptions'optimizeFor = y__}))+              (Data.ProtoLens.maybeLens FileOptions'SPEED)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileOptions "maybe'optimizeFor"+           (Prelude.Maybe FileOptions'OptimizeMode)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileOptions'optimizeFor+                 (\ x__ y__ -> x__{_FileOptions'optimizeFor = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileOptions "goPackage" (Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileOptions'goPackage+                 (\ x__ y__ -> x__{_FileOptions'goPackage = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileOptions "maybe'goPackage"+           (Prelude.Maybe Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileOptions'goPackage+                 (\ x__ y__ -> x__{_FileOptions'goPackage = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileOptions "ccGenericServices"+           (Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileOptions'ccGenericServices+                 (\ x__ y__ -> x__{_FileOptions'ccGenericServices = y__}))+              (Data.ProtoLens.maybeLens Prelude.False)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileOptions "maybe'ccGenericServices"+           (Prelude.Maybe Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileOptions'ccGenericServices+                 (\ x__ y__ -> x__{_FileOptions'ccGenericServices = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileOptions "javaGenericServices"+           (Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileOptions'javaGenericServices+                 (\ x__ y__ -> x__{_FileOptions'javaGenericServices = y__}))+              (Data.ProtoLens.maybeLens Prelude.False)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileOptions "maybe'javaGenericServices"+           (Prelude.Maybe Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileOptions'javaGenericServices+                 (\ x__ y__ -> x__{_FileOptions'javaGenericServices = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileOptions "pyGenericServices"+           (Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileOptions'pyGenericServices+                 (\ x__ y__ -> x__{_FileOptions'pyGenericServices = y__}))+              (Data.ProtoLens.maybeLens Prelude.False)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileOptions "maybe'pyGenericServices"+           (Prelude.Maybe Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileOptions'pyGenericServices+                 (\ x__ y__ -> x__{_FileOptions'pyGenericServices = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileOptions "deprecated" (Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileOptions'deprecated+                 (\ x__ y__ -> x__{_FileOptions'deprecated = y__}))+              (Data.ProtoLens.maybeLens Prelude.False)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileOptions "maybe'deprecated"+           (Prelude.Maybe Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileOptions'deprecated+                 (\ x__ y__ -> x__{_FileOptions'deprecated = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileOptions "ccEnableArenas" (Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileOptions'ccEnableArenas+                 (\ x__ y__ -> x__{_FileOptions'ccEnableArenas = y__}))+              (Data.ProtoLens.maybeLens Prelude.False)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileOptions "maybe'ccEnableArenas"+           (Prelude.Maybe Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileOptions'ccEnableArenas+                 (\ x__ y__ -> x__{_FileOptions'ccEnableArenas = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileOptions "objcClassPrefix"+           (Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileOptions'objcClassPrefix+                 (\ x__ y__ -> x__{_FileOptions'objcClassPrefix = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileOptions "maybe'objcClassPrefix"+           (Prelude.Maybe Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileOptions'objcClassPrefix+                 (\ x__ y__ -> x__{_FileOptions'objcClassPrefix = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileOptions "csharpNamespace"+           (Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileOptions'csharpNamespace+                 (\ x__ y__ -> x__{_FileOptions'csharpNamespace = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileOptions "maybe'csharpNamespace"+           (Prelude.Maybe Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileOptions'csharpNamespace+                 (\ x__ y__ -> x__{_FileOptions'csharpNamespace = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f FileOptions "uninterpretedOption"+           ([UninterpretedOption])+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _FileOptions'uninterpretedOption+                 (\ x__ y__ -> x__{_FileOptions'uninterpretedOption = y__}))+              Prelude.id+instance Data.Default.Class.Default FileOptions where+        def+          = FileOptions{_FileOptions'javaPackage = Prelude.Nothing,+                        _FileOptions'javaOuterClassname = Prelude.Nothing,+                        _FileOptions'javaMultipleFiles = Prelude.Nothing,+                        _FileOptions'javaGenerateEqualsAndHash = Prelude.Nothing,+                        _FileOptions'javaStringCheckUtf8 = Prelude.Nothing,+                        _FileOptions'optimizeFor = Prelude.Nothing,+                        _FileOptions'goPackage = Prelude.Nothing,+                        _FileOptions'ccGenericServices = Prelude.Nothing,+                        _FileOptions'javaGenericServices = Prelude.Nothing,+                        _FileOptions'pyGenericServices = Prelude.Nothing,+                        _FileOptions'deprecated = Prelude.Nothing,+                        _FileOptions'ccEnableArenas = Prelude.Nothing,+                        _FileOptions'objcClassPrefix = Prelude.Nothing,+                        _FileOptions'csharpNamespace = Prelude.Nothing,+                        _FileOptions'uninterpretedOption = [],+                        _FileOptions'_unknownFields = ([])}+instance Data.ProtoLens.Message FileOptions where+        messageName _ = Data.Text.pack "google.protobuf.FileOptions"+        fieldsByTag+          = let javaPackage__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "java_package"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) ::+                               (Lens.Labels.Proxy#) "maybe'javaPackage")))+                      :: Data.ProtoLens.FieldDescriptor FileOptions+                javaOuterClassname__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "java_outer_classname"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) ::+                               (Lens.Labels.Proxy#) "maybe'javaOuterClassname")))+                      :: Data.ProtoLens.FieldDescriptor FileOptions+                javaMultipleFiles__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "java_multiple_files"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) ::+                               (Lens.Labels.Proxy#) "maybe'javaMultipleFiles")))+                      :: Data.ProtoLens.FieldDescriptor FileOptions+                javaGenerateEqualsAndHash__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "java_generate_equals_and_hash"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) ::+                               (Lens.Labels.Proxy#) "maybe'javaGenerateEqualsAndHash")))+                      :: Data.ProtoLens.FieldDescriptor FileOptions+                javaStringCheckUtf8__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "java_string_check_utf8"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) ::+                               (Lens.Labels.Proxy#) "maybe'javaStringCheckUtf8")))+                      :: Data.ProtoLens.FieldDescriptor FileOptions+                optimizeFor__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "optimize_for"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField ::+                         Data.ProtoLens.FieldTypeDescriptor FileOptions'OptimizeMode)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) ::+                               (Lens.Labels.Proxy#) "maybe'optimizeFor")))+                      :: Data.ProtoLens.FieldDescriptor FileOptions+                goPackage__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "go_package"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'goPackage")))+                      :: Data.ProtoLens.FieldDescriptor FileOptions+                ccGenericServices__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "cc_generic_services"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) ::+                               (Lens.Labels.Proxy#) "maybe'ccGenericServices")))+                      :: Data.ProtoLens.FieldDescriptor FileOptions+                javaGenericServices__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "java_generic_services"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) ::+                               (Lens.Labels.Proxy#) "maybe'javaGenericServices")))+                      :: Data.ProtoLens.FieldDescriptor FileOptions+                pyGenericServices__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "py_generic_services"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) ::+                               (Lens.Labels.Proxy#) "maybe'pyGenericServices")))+                      :: Data.ProtoLens.FieldDescriptor FileOptions+                deprecated__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "deprecated"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'deprecated")))+                      :: Data.ProtoLens.FieldDescriptor FileOptions+                ccEnableArenas__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "cc_enable_arenas"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) ::+                               (Lens.Labels.Proxy#) "maybe'ccEnableArenas")))+                      :: Data.ProtoLens.FieldDescriptor FileOptions+                objcClassPrefix__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "objc_class_prefix"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) ::+                               (Lens.Labels.Proxy#) "maybe'objcClassPrefix")))+                      :: Data.ProtoLens.FieldDescriptor FileOptions+                csharpNamespace__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "csharp_namespace"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) ::+                               (Lens.Labels.Proxy#) "maybe'csharpNamespace")))+                      :: Data.ProtoLens.FieldDescriptor FileOptions+                uninterpretedOption__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "uninterpreted_option"+                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                         Data.ProtoLens.FieldTypeDescriptor UninterpretedOption)+                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) ::+                               (Lens.Labels.Proxy#) "uninterpretedOption")))+                      :: Data.ProtoLens.FieldDescriptor FileOptions+              in+              Data.Map.fromList+                [(Data.ProtoLens.Tag 1, javaPackage__field_descriptor),+                 (Data.ProtoLens.Tag 8, javaOuterClassname__field_descriptor),+                 (Data.ProtoLens.Tag 10, javaMultipleFiles__field_descriptor),+                 (Data.ProtoLens.Tag 20,+                  javaGenerateEqualsAndHash__field_descriptor),+                 (Data.ProtoLens.Tag 27, javaStringCheckUtf8__field_descriptor),+                 (Data.ProtoLens.Tag 9, optimizeFor__field_descriptor),+                 (Data.ProtoLens.Tag 11, goPackage__field_descriptor),+                 (Data.ProtoLens.Tag 16, ccGenericServices__field_descriptor),+                 (Data.ProtoLens.Tag 17, javaGenericServices__field_descriptor),+                 (Data.ProtoLens.Tag 18, pyGenericServices__field_descriptor),+                 (Data.ProtoLens.Tag 23, deprecated__field_descriptor),+                 (Data.ProtoLens.Tag 31, ccEnableArenas__field_descriptor),+                 (Data.ProtoLens.Tag 36, objcClassPrefix__field_descriptor),+                 (Data.ProtoLens.Tag 37, csharpNamespace__field_descriptor),+                 (Data.ProtoLens.Tag 999, uninterpretedOption__field_descriptor)]+        unknownFields+          = Lens.Family2.Unchecked.lens _FileOptions'_unknownFields+              (\ x__ y__ -> x__{_FileOptions'_unknownFields = y__})+data FileOptions'OptimizeMode = FileOptions'SPEED+                              | FileOptions'CODE_SIZE+                              | FileOptions'LITE_RUNTIME+                              deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)+instance Data.Default.Class.Default FileOptions'OptimizeMode where+        def = FileOptions'SPEED+instance Data.ProtoLens.FieldDefault FileOptions'OptimizeMode where+        fieldDefault = FileOptions'SPEED+instance Data.ProtoLens.MessageEnum FileOptions'OptimizeMode where+        maybeToEnum 1 = Prelude.Just FileOptions'SPEED+        maybeToEnum 2 = Prelude.Just FileOptions'CODE_SIZE+        maybeToEnum 3 = Prelude.Just FileOptions'LITE_RUNTIME+        maybeToEnum _ = Prelude.Nothing+        showEnum FileOptions'SPEED = "SPEED"+        showEnum FileOptions'CODE_SIZE = "CODE_SIZE"+        showEnum FileOptions'LITE_RUNTIME = "LITE_RUNTIME"+        readEnum "SPEED" = Prelude.Just FileOptions'SPEED+        readEnum "CODE_SIZE" = Prelude.Just FileOptions'CODE_SIZE+        readEnum "LITE_RUNTIME" = Prelude.Just FileOptions'LITE_RUNTIME+        readEnum _ = Prelude.Nothing+instance Prelude.Enum FileOptions'OptimizeMode where+        toEnum k__+          = Prelude.maybe+              (Prelude.error+                 ((Prelude.++) "toEnum: unknown value for enum OptimizeMode: "+                    (Prelude.show k__)))+              Prelude.id+              (Data.ProtoLens.maybeToEnum k__)+        fromEnum FileOptions'SPEED = 1+        fromEnum FileOptions'CODE_SIZE = 2+        fromEnum FileOptions'LITE_RUNTIME = 3+        succ FileOptions'LITE_RUNTIME+          = Prelude.error+              "FileOptions'OptimizeMode.succ: bad argument FileOptions'LITE_RUNTIME. This value would be out of bounds."+        succ FileOptions'SPEED = FileOptions'CODE_SIZE+        succ FileOptions'CODE_SIZE = FileOptions'LITE_RUNTIME+        pred FileOptions'SPEED+          = Prelude.error+              "FileOptions'OptimizeMode.pred: bad argument FileOptions'SPEED. This value would be out of bounds."+        pred FileOptions'CODE_SIZE = FileOptions'SPEED+        pred FileOptions'LITE_RUNTIME = FileOptions'CODE_SIZE+        enumFrom = Data.ProtoLens.Message.Enum.messageEnumFrom+        enumFromTo = Data.ProtoLens.Message.Enum.messageEnumFromTo+        enumFromThen = Data.ProtoLens.Message.Enum.messageEnumFromThen+        enumFromThenTo = Data.ProtoLens.Message.Enum.messageEnumFromThenTo+instance Prelude.Bounded FileOptions'OptimizeMode where+        minBound = FileOptions'SPEED+        maxBound = FileOptions'LITE_RUNTIME+{- | Fields :++    * 'Proto.Google.Protobuf.Descriptor_Fields.annotation' @:: Lens' GeneratedCodeInfo [GeneratedCodeInfo'Annotation]@+ -}+data GeneratedCodeInfo = GeneratedCodeInfo{_GeneratedCodeInfo'annotation+                                           :: ![GeneratedCodeInfo'Annotation],+                                           _GeneratedCodeInfo'_unknownFields ::+                                           !Data.ProtoLens.FieldSet}+                       deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)+instance (Lens.Labels.HasLens' f GeneratedCodeInfo x a, a ~ b) =>+         Lens.Labels.HasLens f GeneratedCodeInfo GeneratedCodeInfo x a b+         where+        lensOf = Lens.Labels.lensOf'+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f GeneratedCodeInfo "annotation"+           ([GeneratedCodeInfo'Annotation])+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _GeneratedCodeInfo'annotation+                 (\ x__ y__ -> x__{_GeneratedCodeInfo'annotation = y__}))+              Prelude.id+instance Data.Default.Class.Default GeneratedCodeInfo where+        def+          = GeneratedCodeInfo{_GeneratedCodeInfo'annotation = [],+                              _GeneratedCodeInfo'_unknownFields = ([])}+instance Data.ProtoLens.Message GeneratedCodeInfo where+        messageName _ = Data.Text.pack "google.protobuf.GeneratedCodeInfo"+        fieldsByTag+          = let annotation__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "annotation"+                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                         Data.ProtoLens.FieldTypeDescriptor GeneratedCodeInfo'Annotation)+                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "annotation")))+                      :: Data.ProtoLens.FieldDescriptor GeneratedCodeInfo+              in+              Data.Map.fromList+                [(Data.ProtoLens.Tag 1, annotation__field_descriptor)]+        unknownFields+          = Lens.Family2.Unchecked.lens _GeneratedCodeInfo'_unknownFields+              (\ x__ y__ -> x__{_GeneratedCodeInfo'_unknownFields = y__})+{- | Fields :++    * 'Proto.Google.Protobuf.Descriptor_Fields.path' @:: Lens' GeneratedCodeInfo'Annotation [Data.Int.Int32]@+    * 'Proto.Google.Protobuf.Descriptor_Fields.sourceFile' @:: Lens' GeneratedCodeInfo'Annotation Data.Text.Text@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'sourceFile' @:: Lens' GeneratedCodeInfo'Annotation (Prelude.Maybe Data.Text.Text)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.begin' @:: Lens' GeneratedCodeInfo'Annotation Data.Int.Int32@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'begin' @:: Lens' GeneratedCodeInfo'Annotation (Prelude.Maybe Data.Int.Int32)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.end' @:: Lens' GeneratedCodeInfo'Annotation Data.Int.Int32@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'end' @:: Lens' GeneratedCodeInfo'Annotation (Prelude.Maybe Data.Int.Int32)@+ -}+data GeneratedCodeInfo'Annotation = GeneratedCodeInfo'Annotation{_GeneratedCodeInfo'Annotation'path+                                                                 :: ![Data.Int.Int32],+                                                                 _GeneratedCodeInfo'Annotation'sourceFile+                                                                 :: !(Prelude.Maybe Data.Text.Text),+                                                                 _GeneratedCodeInfo'Annotation'begin+                                                                 :: !(Prelude.Maybe Data.Int.Int32),+                                                                 _GeneratedCodeInfo'Annotation'end+                                                                 :: !(Prelude.Maybe Data.Int.Int32),+                                                                 _GeneratedCodeInfo'Annotation'_unknownFields+                                                                 :: !Data.ProtoLens.FieldSet}+                                  deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)+instance (Lens.Labels.HasLens' f GeneratedCodeInfo'Annotation x a,+          a ~ b) =>+         Lens.Labels.HasLens f GeneratedCodeInfo'Annotation+           GeneratedCodeInfo'Annotation+           x+           a+           b+         where+        lensOf = Lens.Labels.lensOf'+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f GeneratedCodeInfo'Annotation "path"+           ([Data.Int.Int32])+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _GeneratedCodeInfo'Annotation'path+                 (\ x__ y__ -> x__{_GeneratedCodeInfo'Annotation'path = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f GeneratedCodeInfo'Annotation "sourceFile"+           (Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens+                 _GeneratedCodeInfo'Annotation'sourceFile+                 (\ x__ y__ -> x__{_GeneratedCodeInfo'Annotation'sourceFile = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f GeneratedCodeInfo'Annotation+           "maybe'sourceFile"+           (Prelude.Maybe Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens+                 _GeneratedCodeInfo'Annotation'sourceFile+                 (\ x__ y__ -> x__{_GeneratedCodeInfo'Annotation'sourceFile = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f GeneratedCodeInfo'Annotation "begin"+           (Data.Int.Int32)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _GeneratedCodeInfo'Annotation'begin+                 (\ x__ y__ -> x__{_GeneratedCodeInfo'Annotation'begin = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f GeneratedCodeInfo'Annotation "maybe'begin"+           (Prelude.Maybe Data.Int.Int32)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _GeneratedCodeInfo'Annotation'begin+                 (\ x__ y__ -> x__{_GeneratedCodeInfo'Annotation'begin = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f GeneratedCodeInfo'Annotation "end"+           (Data.Int.Int32)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _GeneratedCodeInfo'Annotation'end+                 (\ x__ y__ -> x__{_GeneratedCodeInfo'Annotation'end = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f GeneratedCodeInfo'Annotation "maybe'end"+           (Prelude.Maybe Data.Int.Int32)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _GeneratedCodeInfo'Annotation'end+                 (\ x__ y__ -> x__{_GeneratedCodeInfo'Annotation'end = y__}))+              Prelude.id+instance Data.Default.Class.Default GeneratedCodeInfo'Annotation+         where+        def+          = GeneratedCodeInfo'Annotation{_GeneratedCodeInfo'Annotation'path =+                                           [],+                                         _GeneratedCodeInfo'Annotation'sourceFile = Prelude.Nothing,+                                         _GeneratedCodeInfo'Annotation'begin = Prelude.Nothing,+                                         _GeneratedCodeInfo'Annotation'end = Prelude.Nothing,+                                         _GeneratedCodeInfo'Annotation'_unknownFields = ([])}+instance Data.ProtoLens.Message GeneratedCodeInfo'Annotation where+        messageName _+          = Data.Text.pack "google.protobuf.GeneratedCodeInfo.Annotation"+        fieldsByTag+          = let path__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "path"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)+                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Packed+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "path")))+                      :: Data.ProtoLens.FieldDescriptor GeneratedCodeInfo'Annotation+                sourceFile__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "source_file"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'sourceFile")))+                      :: Data.ProtoLens.FieldDescriptor GeneratedCodeInfo'Annotation+                begin__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "begin"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'begin")))+                      :: Data.ProtoLens.FieldDescriptor GeneratedCodeInfo'Annotation+                end__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "end"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'end")))+                      :: Data.ProtoLens.FieldDescriptor GeneratedCodeInfo'Annotation+              in+              Data.Map.fromList+                [(Data.ProtoLens.Tag 1, path__field_descriptor),+                 (Data.ProtoLens.Tag 2, sourceFile__field_descriptor),+                 (Data.ProtoLens.Tag 3, begin__field_descriptor),+                 (Data.ProtoLens.Tag 4, end__field_descriptor)]+        unknownFields+          = Lens.Family2.Unchecked.lens+              _GeneratedCodeInfo'Annotation'_unknownFields+              (\ x__ y__ ->+                 x__{_GeneratedCodeInfo'Annotation'_unknownFields = y__})+{- | Fields :++    * 'Proto.Google.Protobuf.Descriptor_Fields.messageSetWireFormat' @:: Lens' MessageOptions Prelude.Bool@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'messageSetWireFormat' @:: Lens' MessageOptions (Prelude.Maybe Prelude.Bool)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.noStandardDescriptorAccessor' @:: Lens' MessageOptions Prelude.Bool@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'noStandardDescriptorAccessor' @:: Lens' MessageOptions (Prelude.Maybe Prelude.Bool)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.deprecated' @:: Lens' MessageOptions Prelude.Bool@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'deprecated' @:: Lens' MessageOptions (Prelude.Maybe Prelude.Bool)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.mapEntry' @:: Lens' MessageOptions Prelude.Bool@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'mapEntry' @:: Lens' MessageOptions (Prelude.Maybe Prelude.Bool)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.uninterpretedOption' @:: Lens' MessageOptions [UninterpretedOption]@+ -}+data MessageOptions = MessageOptions{_MessageOptions'messageSetWireFormat+                                     :: !(Prelude.Maybe Prelude.Bool),+                                     _MessageOptions'noStandardDescriptorAccessor ::+                                     !(Prelude.Maybe Prelude.Bool),+                                     _MessageOptions'deprecated :: !(Prelude.Maybe Prelude.Bool),+                                     _MessageOptions'mapEntry :: !(Prelude.Maybe Prelude.Bool),+                                     _MessageOptions'uninterpretedOption :: ![UninterpretedOption],+                                     _MessageOptions'_unknownFields :: !Data.ProtoLens.FieldSet}+                    deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)+instance (Lens.Labels.HasLens' f MessageOptions x a, a ~ b) =>+         Lens.Labels.HasLens f MessageOptions MessageOptions x a b+         where+        lensOf = Lens.Labels.lensOf'+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f MessageOptions "messageSetWireFormat"+           (Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _MessageOptions'messageSetWireFormat+                 (\ x__ y__ -> x__{_MessageOptions'messageSetWireFormat = y__}))+              (Data.ProtoLens.maybeLens Prelude.False)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f MessageOptions "maybe'messageSetWireFormat"+           (Prelude.Maybe Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _MessageOptions'messageSetWireFormat+                 (\ x__ y__ -> x__{_MessageOptions'messageSetWireFormat = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f MessageOptions+           "noStandardDescriptorAccessor"+           (Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens+                 _MessageOptions'noStandardDescriptorAccessor+                 (\ x__ y__ ->+                    x__{_MessageOptions'noStandardDescriptorAccessor = y__}))+              (Data.ProtoLens.maybeLens Prelude.False)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f MessageOptions+           "maybe'noStandardDescriptorAccessor"+           (Prelude.Maybe Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens+                 _MessageOptions'noStandardDescriptorAccessor+                 (\ x__ y__ ->+                    x__{_MessageOptions'noStandardDescriptorAccessor = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f MessageOptions "deprecated" (Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _MessageOptions'deprecated+                 (\ x__ y__ -> x__{_MessageOptions'deprecated = y__}))+              (Data.ProtoLens.maybeLens Prelude.False)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f MessageOptions "maybe'deprecated"+           (Prelude.Maybe Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _MessageOptions'deprecated+                 (\ x__ y__ -> x__{_MessageOptions'deprecated = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f MessageOptions "mapEntry" (Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _MessageOptions'mapEntry+                 (\ x__ y__ -> x__{_MessageOptions'mapEntry = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f MessageOptions "maybe'mapEntry"+           (Prelude.Maybe Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _MessageOptions'mapEntry+                 (\ x__ y__ -> x__{_MessageOptions'mapEntry = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f MessageOptions "uninterpretedOption"+           ([UninterpretedOption])+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _MessageOptions'uninterpretedOption+                 (\ x__ y__ -> x__{_MessageOptions'uninterpretedOption = y__}))+              Prelude.id+instance Data.Default.Class.Default MessageOptions where+        def+          = MessageOptions{_MessageOptions'messageSetWireFormat =+                             Prelude.Nothing,+                           _MessageOptions'noStandardDescriptorAccessor = Prelude.Nothing,+                           _MessageOptions'deprecated = Prelude.Nothing,+                           _MessageOptions'mapEntry = Prelude.Nothing,+                           _MessageOptions'uninterpretedOption = [],+                           _MessageOptions'_unknownFields = ([])}+instance Data.ProtoLens.Message MessageOptions where+        messageName _ = Data.Text.pack "google.protobuf.MessageOptions"+        fieldsByTag+          = let messageSetWireFormat__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "message_set_wire_format"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) ::+                               (Lens.Labels.Proxy#) "maybe'messageSetWireFormat")))+                      :: Data.ProtoLens.FieldDescriptor MessageOptions+                noStandardDescriptorAccessor__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "no_standard_descriptor_accessor"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) ::+                               (Lens.Labels.Proxy#) "maybe'noStandardDescriptorAccessor")))+                      :: Data.ProtoLens.FieldDescriptor MessageOptions+                deprecated__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "deprecated"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'deprecated")))+                      :: Data.ProtoLens.FieldDescriptor MessageOptions+                mapEntry__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "map_entry"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'mapEntry")))+                      :: Data.ProtoLens.FieldDescriptor MessageOptions+                uninterpretedOption__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "uninterpreted_option"+                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                         Data.ProtoLens.FieldTypeDescriptor UninterpretedOption)+                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) ::+                               (Lens.Labels.Proxy#) "uninterpretedOption")))+                      :: Data.ProtoLens.FieldDescriptor MessageOptions+              in+              Data.Map.fromList+                [(Data.ProtoLens.Tag 1, messageSetWireFormat__field_descriptor),+                 (Data.ProtoLens.Tag 2,+                  noStandardDescriptorAccessor__field_descriptor),+                 (Data.ProtoLens.Tag 3, deprecated__field_descriptor),+                 (Data.ProtoLens.Tag 7, mapEntry__field_descriptor),+                 (Data.ProtoLens.Tag 999, uninterpretedOption__field_descriptor)]+        unknownFields+          = Lens.Family2.Unchecked.lens _MessageOptions'_unknownFields+              (\ x__ y__ -> x__{_MessageOptions'_unknownFields = y__})+{- | Fields :++    * 'Proto.Google.Protobuf.Descriptor_Fields.name' @:: Lens' MethodDescriptorProto Data.Text.Text@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'name' @:: Lens' MethodDescriptorProto (Prelude.Maybe Data.Text.Text)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.inputType' @:: Lens' MethodDescriptorProto Data.Text.Text@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'inputType' @:: Lens' MethodDescriptorProto (Prelude.Maybe Data.Text.Text)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.outputType' @:: Lens' MethodDescriptorProto Data.Text.Text@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'outputType' @:: Lens' MethodDescriptorProto (Prelude.Maybe Data.Text.Text)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.options' @:: Lens' MethodDescriptorProto MethodOptions@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'options' @:: Lens' MethodDescriptorProto (Prelude.Maybe MethodOptions)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.clientStreaming' @:: Lens' MethodDescriptorProto Prelude.Bool@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'clientStreaming' @:: Lens' MethodDescriptorProto (Prelude.Maybe Prelude.Bool)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.serverStreaming' @:: Lens' MethodDescriptorProto Prelude.Bool@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'serverStreaming' @:: Lens' MethodDescriptorProto (Prelude.Maybe Prelude.Bool)@+ -}+data MethodDescriptorProto = MethodDescriptorProto{_MethodDescriptorProto'name+                                                   :: !(Prelude.Maybe Data.Text.Text),+                                                   _MethodDescriptorProto'inputType ::+                                                   !(Prelude.Maybe Data.Text.Text),+                                                   _MethodDescriptorProto'outputType ::+                                                   !(Prelude.Maybe Data.Text.Text),+                                                   _MethodDescriptorProto'options ::+                                                   !(Prelude.Maybe MethodOptions),+                                                   _MethodDescriptorProto'clientStreaming ::+                                                   !(Prelude.Maybe Prelude.Bool),+                                                   _MethodDescriptorProto'serverStreaming ::+                                                   !(Prelude.Maybe Prelude.Bool),+                                                   _MethodDescriptorProto'_unknownFields ::+                                                   !Data.ProtoLens.FieldSet}+                           deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)+instance (Lens.Labels.HasLens' f MethodDescriptorProto x a,+          a ~ b) =>+         Lens.Labels.HasLens f MethodDescriptorProto MethodDescriptorProto x+           a+           b+         where+        lensOf = Lens.Labels.lensOf'+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f MethodDescriptorProto "name"+           (Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _MethodDescriptorProto'name+                 (\ x__ y__ -> x__{_MethodDescriptorProto'name = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f MethodDescriptorProto "maybe'name"+           (Prelude.Maybe Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _MethodDescriptorProto'name+                 (\ x__ y__ -> x__{_MethodDescriptorProto'name = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f MethodDescriptorProto "inputType"+           (Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _MethodDescriptorProto'inputType+                 (\ x__ y__ -> x__{_MethodDescriptorProto'inputType = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f MethodDescriptorProto "maybe'inputType"+           (Prelude.Maybe Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _MethodDescriptorProto'inputType+                 (\ x__ y__ -> x__{_MethodDescriptorProto'inputType = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f MethodDescriptorProto "outputType"+           (Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _MethodDescriptorProto'outputType+                 (\ x__ y__ -> x__{_MethodDescriptorProto'outputType = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f MethodDescriptorProto "maybe'outputType"+           (Prelude.Maybe Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _MethodDescriptorProto'outputType+                 (\ x__ y__ -> x__{_MethodDescriptorProto'outputType = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f MethodDescriptorProto "options"+           (MethodOptions)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _MethodDescriptorProto'options+                 (\ x__ y__ -> x__{_MethodDescriptorProto'options = y__}))+              (Data.ProtoLens.maybeLens Data.Default.Class.def)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f MethodDescriptorProto "maybe'options"+           (Prelude.Maybe MethodOptions)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _MethodDescriptorProto'options+                 (\ x__ y__ -> x__{_MethodDescriptorProto'options = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f MethodDescriptorProto "clientStreaming"+           (Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _MethodDescriptorProto'clientStreaming+                 (\ x__ y__ -> x__{_MethodDescriptorProto'clientStreaming = y__}))+              (Data.ProtoLens.maybeLens Prelude.False)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f MethodDescriptorProto+           "maybe'clientStreaming"+           (Prelude.Maybe Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _MethodDescriptorProto'clientStreaming+                 (\ x__ y__ -> x__{_MethodDescriptorProto'clientStreaming = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f MethodDescriptorProto "serverStreaming"+           (Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _MethodDescriptorProto'serverStreaming+                 (\ x__ y__ -> x__{_MethodDescriptorProto'serverStreaming = y__}))+              (Data.ProtoLens.maybeLens Prelude.False)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f MethodDescriptorProto+           "maybe'serverStreaming"+           (Prelude.Maybe Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _MethodDescriptorProto'serverStreaming+                 (\ x__ y__ -> x__{_MethodDescriptorProto'serverStreaming = y__}))+              Prelude.id+instance Data.Default.Class.Default MethodDescriptorProto where+        def+          = MethodDescriptorProto{_MethodDescriptorProto'name =+                                    Prelude.Nothing,+                                  _MethodDescriptorProto'inputType = Prelude.Nothing,+                                  _MethodDescriptorProto'outputType = Prelude.Nothing,+                                  _MethodDescriptorProto'options = Prelude.Nothing,+                                  _MethodDescriptorProto'clientStreaming = Prelude.Nothing,+                                  _MethodDescriptorProto'serverStreaming = Prelude.Nothing,+                                  _MethodDescriptorProto'_unknownFields = ([])}+instance Data.ProtoLens.Message MethodDescriptorProto where+        messageName _+          = Data.Text.pack "google.protobuf.MethodDescriptorProto"+        fieldsByTag+          = let name__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "name"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'name")))+                      :: Data.ProtoLens.FieldDescriptor MethodDescriptorProto+                inputType__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "input_type"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'inputType")))+                      :: Data.ProtoLens.FieldDescriptor MethodDescriptorProto+                outputType__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "output_type"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'outputType")))+                      :: Data.ProtoLens.FieldDescriptor MethodDescriptorProto+                options__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "options"+                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                         Data.ProtoLens.FieldTypeDescriptor MethodOptions)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'options")))+                      :: Data.ProtoLens.FieldDescriptor MethodDescriptorProto+                clientStreaming__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "client_streaming"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) ::+                               (Lens.Labels.Proxy#) "maybe'clientStreaming")))+                      :: Data.ProtoLens.FieldDescriptor MethodDescriptorProto+                serverStreaming__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "server_streaming"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) ::+                               (Lens.Labels.Proxy#) "maybe'serverStreaming")))+                      :: Data.ProtoLens.FieldDescriptor MethodDescriptorProto+              in+              Data.Map.fromList+                [(Data.ProtoLens.Tag 1, name__field_descriptor),+                 (Data.ProtoLens.Tag 2, inputType__field_descriptor),+                 (Data.ProtoLens.Tag 3, outputType__field_descriptor),+                 (Data.ProtoLens.Tag 4, options__field_descriptor),+                 (Data.ProtoLens.Tag 5, clientStreaming__field_descriptor),+                 (Data.ProtoLens.Tag 6, serverStreaming__field_descriptor)]+        unknownFields+          = Lens.Family2.Unchecked.lens _MethodDescriptorProto'_unknownFields+              (\ x__ y__ -> x__{_MethodDescriptorProto'_unknownFields = y__})+{- | Fields :++    * 'Proto.Google.Protobuf.Descriptor_Fields.deprecated' @:: Lens' MethodOptions Prelude.Bool@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'deprecated' @:: Lens' MethodOptions (Prelude.Maybe Prelude.Bool)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.uninterpretedOption' @:: Lens' MethodOptions [UninterpretedOption]@+ -}+data MethodOptions = MethodOptions{_MethodOptions'deprecated ::+                                   !(Prelude.Maybe Prelude.Bool),+                                   _MethodOptions'uninterpretedOption :: ![UninterpretedOption],+                                   _MethodOptions'_unknownFields :: !Data.ProtoLens.FieldSet}+                   deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)+instance (Lens.Labels.HasLens' f MethodOptions x a, a ~ b) =>+         Lens.Labels.HasLens f MethodOptions MethodOptions x a b+         where+        lensOf = Lens.Labels.lensOf'+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f MethodOptions "deprecated" (Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _MethodOptions'deprecated+                 (\ x__ y__ -> x__{_MethodOptions'deprecated = y__}))+              (Data.ProtoLens.maybeLens Prelude.False)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f MethodOptions "maybe'deprecated"+           (Prelude.Maybe Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _MethodOptions'deprecated+                 (\ x__ y__ -> x__{_MethodOptions'deprecated = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f MethodOptions "uninterpretedOption"+           ([UninterpretedOption])+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _MethodOptions'uninterpretedOption+                 (\ x__ y__ -> x__{_MethodOptions'uninterpretedOption = y__}))+              Prelude.id+instance Data.Default.Class.Default MethodOptions where+        def+          = MethodOptions{_MethodOptions'deprecated = Prelude.Nothing,+                          _MethodOptions'uninterpretedOption = [],+                          _MethodOptions'_unknownFields = ([])}+instance Data.ProtoLens.Message MethodOptions where+        messageName _ = Data.Text.pack "google.protobuf.MethodOptions"+        fieldsByTag+          = let deprecated__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "deprecated"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'deprecated")))+                      :: Data.ProtoLens.FieldDescriptor MethodOptions+                uninterpretedOption__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "uninterpreted_option"+                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                         Data.ProtoLens.FieldTypeDescriptor UninterpretedOption)+                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) ::+                               (Lens.Labels.Proxy#) "uninterpretedOption")))+                      :: Data.ProtoLens.FieldDescriptor MethodOptions+              in+              Data.Map.fromList+                [(Data.ProtoLens.Tag 33, deprecated__field_descriptor),+                 (Data.ProtoLens.Tag 999, uninterpretedOption__field_descriptor)]+        unknownFields+          = Lens.Family2.Unchecked.lens _MethodOptions'_unknownFields+              (\ x__ y__ -> x__{_MethodOptions'_unknownFields = y__})+{- | Fields :++    * 'Proto.Google.Protobuf.Descriptor_Fields.name' @:: Lens' OneofDescriptorProto Data.Text.Text@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'name' @:: Lens' OneofDescriptorProto (Prelude.Maybe Data.Text.Text)@+ -}+data OneofDescriptorProto = OneofDescriptorProto{_OneofDescriptorProto'name+                                                 :: !(Prelude.Maybe Data.Text.Text),+                                                 _OneofDescriptorProto'_unknownFields ::+                                                 !Data.ProtoLens.FieldSet}+                          deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)+instance (Lens.Labels.HasLens' f OneofDescriptorProto x a,+          a ~ b) =>+         Lens.Labels.HasLens f OneofDescriptorProto OneofDescriptorProto x a+           b+         where+        lensOf = Lens.Labels.lensOf'+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f OneofDescriptorProto "name" (Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _OneofDescriptorProto'name+                 (\ x__ y__ -> x__{_OneofDescriptorProto'name = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f OneofDescriptorProto "maybe'name"+           (Prelude.Maybe Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _OneofDescriptorProto'name+                 (\ x__ y__ -> x__{_OneofDescriptorProto'name = y__}))+              Prelude.id+instance Data.Default.Class.Default OneofDescriptorProto where+        def+          = OneofDescriptorProto{_OneofDescriptorProto'name =+                                   Prelude.Nothing,+                                 _OneofDescriptorProto'_unknownFields = ([])}+instance Data.ProtoLens.Message OneofDescriptorProto where+        messageName _+          = Data.Text.pack "google.protobuf.OneofDescriptorProto"+        fieldsByTag+          = let name__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "name"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'name")))+                      :: Data.ProtoLens.FieldDescriptor OneofDescriptorProto+              in+              Data.Map.fromList [(Data.ProtoLens.Tag 1, name__field_descriptor)]+        unknownFields+          = Lens.Family2.Unchecked.lens _OneofDescriptorProto'_unknownFields+              (\ x__ y__ -> x__{_OneofDescriptorProto'_unknownFields = y__})+{- | Fields :++    * 'Proto.Google.Protobuf.Descriptor_Fields.name' @:: Lens' ServiceDescriptorProto Data.Text.Text@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'name' @:: Lens' ServiceDescriptorProto (Prelude.Maybe Data.Text.Text)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.method' @:: Lens' ServiceDescriptorProto [MethodDescriptorProto]@+    * 'Proto.Google.Protobuf.Descriptor_Fields.options' @:: Lens' ServiceDescriptorProto ServiceOptions@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'options' @:: Lens' ServiceDescriptorProto (Prelude.Maybe ServiceOptions)@+ -}+data ServiceDescriptorProto = ServiceDescriptorProto{_ServiceDescriptorProto'name+                                                     :: !(Prelude.Maybe Data.Text.Text),+                                                     _ServiceDescriptorProto'method ::+                                                     ![MethodDescriptorProto],+                                                     _ServiceDescriptorProto'options ::+                                                     !(Prelude.Maybe ServiceOptions),+                                                     _ServiceDescriptorProto'_unknownFields ::+                                                     !Data.ProtoLens.FieldSet}+                            deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)+instance (Lens.Labels.HasLens' f ServiceDescriptorProto x a,+          a ~ b) =>+         Lens.Labels.HasLens f ServiceDescriptorProto ServiceDescriptorProto+           x+           a+           b+         where+        lensOf = Lens.Labels.lensOf'+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f ServiceDescriptorProto "name"+           (Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _ServiceDescriptorProto'name+                 (\ x__ y__ -> x__{_ServiceDescriptorProto'name = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f ServiceDescriptorProto "maybe'name"+           (Prelude.Maybe Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _ServiceDescriptorProto'name+                 (\ x__ y__ -> x__{_ServiceDescriptorProto'name = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f ServiceDescriptorProto "method"+           ([MethodDescriptorProto])+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _ServiceDescriptorProto'method+                 (\ x__ y__ -> x__{_ServiceDescriptorProto'method = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f ServiceDescriptorProto "options"+           (ServiceOptions)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _ServiceDescriptorProto'options+                 (\ x__ y__ -> x__{_ServiceDescriptorProto'options = y__}))+              (Data.ProtoLens.maybeLens Data.Default.Class.def)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f ServiceDescriptorProto "maybe'options"+           (Prelude.Maybe ServiceOptions)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _ServiceDescriptorProto'options+                 (\ x__ y__ -> x__{_ServiceDescriptorProto'options = y__}))+              Prelude.id+instance Data.Default.Class.Default ServiceDescriptorProto where+        def+          = ServiceDescriptorProto{_ServiceDescriptorProto'name =+                                     Prelude.Nothing,+                                   _ServiceDescriptorProto'method = [],+                                   _ServiceDescriptorProto'options = Prelude.Nothing,+                                   _ServiceDescriptorProto'_unknownFields = ([])}+instance Data.ProtoLens.Message ServiceDescriptorProto where+        messageName _+          = Data.Text.pack "google.protobuf.ServiceDescriptorProto"+        fieldsByTag+          = let name__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "name"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'name")))+                      :: Data.ProtoLens.FieldDescriptor ServiceDescriptorProto+                method__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "method"+                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                         Data.ProtoLens.FieldTypeDescriptor MethodDescriptorProto)+                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "method")))+                      :: Data.ProtoLens.FieldDescriptor ServiceDescriptorProto+                options__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "options"+                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                         Data.ProtoLens.FieldTypeDescriptor ServiceOptions)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'options")))+                      :: Data.ProtoLens.FieldDescriptor ServiceDescriptorProto+              in+              Data.Map.fromList+                [(Data.ProtoLens.Tag 1, name__field_descriptor),+                 (Data.ProtoLens.Tag 2, method__field_descriptor),+                 (Data.ProtoLens.Tag 3, options__field_descriptor)]+        unknownFields+          = Lens.Family2.Unchecked.lens+              _ServiceDescriptorProto'_unknownFields+              (\ x__ y__ -> x__{_ServiceDescriptorProto'_unknownFields = y__})+{- | Fields :++    * 'Proto.Google.Protobuf.Descriptor_Fields.deprecated' @:: Lens' ServiceOptions Prelude.Bool@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'deprecated' @:: Lens' ServiceOptions (Prelude.Maybe Prelude.Bool)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.uninterpretedOption' @:: Lens' ServiceOptions [UninterpretedOption]@+ -}+data ServiceOptions = ServiceOptions{_ServiceOptions'deprecated ::+                                     !(Prelude.Maybe Prelude.Bool),+                                     _ServiceOptions'uninterpretedOption :: ![UninterpretedOption],+                                     _ServiceOptions'_unknownFields :: !Data.ProtoLens.FieldSet}+                    deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)+instance (Lens.Labels.HasLens' f ServiceOptions x a, a ~ b) =>+         Lens.Labels.HasLens f ServiceOptions ServiceOptions x a b+         where+        lensOf = Lens.Labels.lensOf'+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f ServiceOptions "deprecated" (Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _ServiceOptions'deprecated+                 (\ x__ y__ -> x__{_ServiceOptions'deprecated = y__}))+              (Data.ProtoLens.maybeLens Prelude.False)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f ServiceOptions "maybe'deprecated"+           (Prelude.Maybe Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _ServiceOptions'deprecated+                 (\ x__ y__ -> x__{_ServiceOptions'deprecated = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f ServiceOptions "uninterpretedOption"+           ([UninterpretedOption])+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _ServiceOptions'uninterpretedOption+                 (\ x__ y__ -> x__{_ServiceOptions'uninterpretedOption = y__}))+              Prelude.id+instance Data.Default.Class.Default ServiceOptions where+        def+          = ServiceOptions{_ServiceOptions'deprecated = Prelude.Nothing,+                           _ServiceOptions'uninterpretedOption = [],+                           _ServiceOptions'_unknownFields = ([])}+instance Data.ProtoLens.Message ServiceOptions where+        messageName _ = Data.Text.pack "google.protobuf.ServiceOptions"+        fieldsByTag+          = let deprecated__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "deprecated"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'deprecated")))+                      :: Data.ProtoLens.FieldDescriptor ServiceOptions+                uninterpretedOption__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "uninterpreted_option"+                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                         Data.ProtoLens.FieldTypeDescriptor UninterpretedOption)+                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) ::+                               (Lens.Labels.Proxy#) "uninterpretedOption")))+                      :: Data.ProtoLens.FieldDescriptor ServiceOptions+              in+              Data.Map.fromList+                [(Data.ProtoLens.Tag 33, deprecated__field_descriptor),+                 (Data.ProtoLens.Tag 999, uninterpretedOption__field_descriptor)]+        unknownFields+          = Lens.Family2.Unchecked.lens _ServiceOptions'_unknownFields+              (\ x__ y__ -> x__{_ServiceOptions'_unknownFields = y__})+{- | Fields :++    * 'Proto.Google.Protobuf.Descriptor_Fields.location' @:: Lens' SourceCodeInfo [SourceCodeInfo'Location]@+ -}+data SourceCodeInfo = SourceCodeInfo{_SourceCodeInfo'location ::+                                     ![SourceCodeInfo'Location],+                                     _SourceCodeInfo'_unknownFields :: !Data.ProtoLens.FieldSet}+                    deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)+instance (Lens.Labels.HasLens' f SourceCodeInfo x a, a ~ b) =>+         Lens.Labels.HasLens f SourceCodeInfo SourceCodeInfo x a b+         where+        lensOf = Lens.Labels.lensOf'+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f SourceCodeInfo "location"+           ([SourceCodeInfo'Location])+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _SourceCodeInfo'location+                 (\ x__ y__ -> x__{_SourceCodeInfo'location = y__}))+              Prelude.id+instance Data.Default.Class.Default SourceCodeInfo where+        def+          = SourceCodeInfo{_SourceCodeInfo'location = [],+                           _SourceCodeInfo'_unknownFields = ([])}+instance Data.ProtoLens.Message SourceCodeInfo where+        messageName _ = Data.Text.pack "google.protobuf.SourceCodeInfo"+        fieldsByTag+          = let location__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "location"+                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                         Data.ProtoLens.FieldTypeDescriptor SourceCodeInfo'Location)+                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "location")))+                      :: Data.ProtoLens.FieldDescriptor SourceCodeInfo+              in+              Data.Map.fromList+                [(Data.ProtoLens.Tag 1, location__field_descriptor)]+        unknownFields+          = Lens.Family2.Unchecked.lens _SourceCodeInfo'_unknownFields+              (\ x__ y__ -> x__{_SourceCodeInfo'_unknownFields = y__})+{- | Fields :++    * 'Proto.Google.Protobuf.Descriptor_Fields.path' @:: Lens' SourceCodeInfo'Location [Data.Int.Int32]@+    * 'Proto.Google.Protobuf.Descriptor_Fields.span' @:: Lens' SourceCodeInfo'Location [Data.Int.Int32]@+    * 'Proto.Google.Protobuf.Descriptor_Fields.leadingComments' @:: Lens' SourceCodeInfo'Location Data.Text.Text@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'leadingComments' @:: Lens' SourceCodeInfo'Location (Prelude.Maybe Data.Text.Text)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.trailingComments' @:: Lens' SourceCodeInfo'Location Data.Text.Text@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'trailingComments' @:: Lens' SourceCodeInfo'Location (Prelude.Maybe Data.Text.Text)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.leadingDetachedComments' @:: Lens' SourceCodeInfo'Location [Data.Text.Text]@+ -}+data SourceCodeInfo'Location = SourceCodeInfo'Location{_SourceCodeInfo'Location'path+                                                       :: ![Data.Int.Int32],+                                                       _SourceCodeInfo'Location'span ::+                                                       ![Data.Int.Int32],+                                                       _SourceCodeInfo'Location'leadingComments ::+                                                       !(Prelude.Maybe Data.Text.Text),+                                                       _SourceCodeInfo'Location'trailingComments ::+                                                       !(Prelude.Maybe Data.Text.Text),+                                                       _SourceCodeInfo'Location'leadingDetachedComments+                                                       :: ![Data.Text.Text],+                                                       _SourceCodeInfo'Location'_unknownFields ::+                                                       !Data.ProtoLens.FieldSet}+                             deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)+instance (Lens.Labels.HasLens' f SourceCodeInfo'Location x a,+          a ~ b) =>+         Lens.Labels.HasLens f SourceCodeInfo'Location+           SourceCodeInfo'Location+           x+           a+           b+         where+        lensOf = Lens.Labels.lensOf'+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f SourceCodeInfo'Location "path"+           ([Data.Int.Int32])+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _SourceCodeInfo'Location'path+                 (\ x__ y__ -> x__{_SourceCodeInfo'Location'path = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f SourceCodeInfo'Location "span"+           ([Data.Int.Int32])+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _SourceCodeInfo'Location'span+                 (\ x__ y__ -> x__{_SourceCodeInfo'Location'span = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f SourceCodeInfo'Location "leadingComments"+           (Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens+                 _SourceCodeInfo'Location'leadingComments+                 (\ x__ y__ -> x__{_SourceCodeInfo'Location'leadingComments = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f SourceCodeInfo'Location+           "maybe'leadingComments"+           (Prelude.Maybe Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens+                 _SourceCodeInfo'Location'leadingComments+                 (\ x__ y__ -> x__{_SourceCodeInfo'Location'leadingComments = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f SourceCodeInfo'Location "trailingComments"+           (Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens+                 _SourceCodeInfo'Location'trailingComments+                 (\ x__ y__ ->+                    x__{_SourceCodeInfo'Location'trailingComments = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f SourceCodeInfo'Location+           "maybe'trailingComments"+           (Prelude.Maybe Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens+                 _SourceCodeInfo'Location'trailingComments+                 (\ x__ y__ ->+                    x__{_SourceCodeInfo'Location'trailingComments = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f SourceCodeInfo'Location+           "leadingDetachedComments"+           ([Data.Text.Text])+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens+                 _SourceCodeInfo'Location'leadingDetachedComments+                 (\ x__ y__ ->+                    x__{_SourceCodeInfo'Location'leadingDetachedComments = y__}))+              Prelude.id+instance Data.Default.Class.Default SourceCodeInfo'Location where+        def+          = SourceCodeInfo'Location{_SourceCodeInfo'Location'path = [],+                                    _SourceCodeInfo'Location'span = [],+                                    _SourceCodeInfo'Location'leadingComments = Prelude.Nothing,+                                    _SourceCodeInfo'Location'trailingComments = Prelude.Nothing,+                                    _SourceCodeInfo'Location'leadingDetachedComments = [],+                                    _SourceCodeInfo'Location'_unknownFields = ([])}+instance Data.ProtoLens.Message SourceCodeInfo'Location where+        messageName _+          = Data.Text.pack "google.protobuf.SourceCodeInfo.Location"+        fieldsByTag+          = let path__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "path"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)+                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Packed+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "path")))+                      :: Data.ProtoLens.FieldDescriptor SourceCodeInfo'Location+                span__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "span"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)+                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Packed+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "span")))+                      :: Data.ProtoLens.FieldDescriptor SourceCodeInfo'Location+                leadingComments__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "leading_comments"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) ::+                               (Lens.Labels.Proxy#) "maybe'leadingComments")))+                      :: Data.ProtoLens.FieldDescriptor SourceCodeInfo'Location+                trailingComments__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "trailing_comments"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) ::+                               (Lens.Labels.Proxy#) "maybe'trailingComments")))+                      :: Data.ProtoLens.FieldDescriptor SourceCodeInfo'Location+                leadingDetachedComments__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "leading_detached_comments"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) ::+                               (Lens.Labels.Proxy#) "leadingDetachedComments")))+                      :: Data.ProtoLens.FieldDescriptor SourceCodeInfo'Location+              in+              Data.Map.fromList+                [(Data.ProtoLens.Tag 1, path__field_descriptor),+                 (Data.ProtoLens.Tag 2, span__field_descriptor),+                 (Data.ProtoLens.Tag 3, leadingComments__field_descriptor),+                 (Data.ProtoLens.Tag 4, trailingComments__field_descriptor),+                 (Data.ProtoLens.Tag 6, leadingDetachedComments__field_descriptor)]+        unknownFields+          = Lens.Family2.Unchecked.lens+              _SourceCodeInfo'Location'_unknownFields+              (\ x__ y__ -> x__{_SourceCodeInfo'Location'_unknownFields = y__})+{- | Fields :++    * 'Proto.Google.Protobuf.Descriptor_Fields.name' @:: Lens' UninterpretedOption [UninterpretedOption'NamePart]@+    * 'Proto.Google.Protobuf.Descriptor_Fields.identifierValue' @:: Lens' UninterpretedOption Data.Text.Text@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'identifierValue' @:: Lens' UninterpretedOption (Prelude.Maybe Data.Text.Text)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.positiveIntValue' @:: Lens' UninterpretedOption Data.Word.Word64@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'positiveIntValue' @:: Lens' UninterpretedOption (Prelude.Maybe Data.Word.Word64)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.negativeIntValue' @:: Lens' UninterpretedOption Data.Int.Int64@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'negativeIntValue' @:: Lens' UninterpretedOption (Prelude.Maybe Data.Int.Int64)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.doubleValue' @:: Lens' UninterpretedOption Prelude.Double@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'doubleValue' @:: Lens' UninterpretedOption (Prelude.Maybe Prelude.Double)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.stringValue' @:: Lens' UninterpretedOption Data.ByteString.ByteString@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'stringValue' @:: Lens' UninterpretedOption+  (Prelude.Maybe Data.ByteString.ByteString)@+    * 'Proto.Google.Protobuf.Descriptor_Fields.aggregateValue' @:: Lens' UninterpretedOption Data.Text.Text@+    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'aggregateValue' @:: Lens' UninterpretedOption (Prelude.Maybe Data.Text.Text)@+ -}+data UninterpretedOption = UninterpretedOption{_UninterpretedOption'name+                                               :: ![UninterpretedOption'NamePart],+                                               _UninterpretedOption'identifierValue ::+                                               !(Prelude.Maybe Data.Text.Text),+                                               _UninterpretedOption'positiveIntValue ::+                                               !(Prelude.Maybe Data.Word.Word64),+                                               _UninterpretedOption'negativeIntValue ::+                                               !(Prelude.Maybe Data.Int.Int64),+                                               _UninterpretedOption'doubleValue ::+                                               !(Prelude.Maybe Prelude.Double),+                                               _UninterpretedOption'stringValue ::+                                               !(Prelude.Maybe Data.ByteString.ByteString),+                                               _UninterpretedOption'aggregateValue ::+                                               !(Prelude.Maybe Data.Text.Text),+                                               _UninterpretedOption'_unknownFields ::+                                               !Data.ProtoLens.FieldSet}+                         deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)+instance (Lens.Labels.HasLens' f UninterpretedOption x a, a ~ b) =>+         Lens.Labels.HasLens f UninterpretedOption UninterpretedOption x a b+         where+        lensOf = Lens.Labels.lensOf'+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f UninterpretedOption "name"+           ([UninterpretedOption'NamePart])+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _UninterpretedOption'name+                 (\ x__ y__ -> x__{_UninterpretedOption'name = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f UninterpretedOption "identifierValue"+           (Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _UninterpretedOption'identifierValue+                 (\ x__ y__ -> x__{_UninterpretedOption'identifierValue = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f UninterpretedOption "maybe'identifierValue"+           (Prelude.Maybe Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _UninterpretedOption'identifierValue+                 (\ x__ y__ -> x__{_UninterpretedOption'identifierValue = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f UninterpretedOption "positiveIntValue"+           (Data.Word.Word64)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _UninterpretedOption'positiveIntValue+                 (\ x__ y__ -> x__{_UninterpretedOption'positiveIntValue = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f UninterpretedOption "maybe'positiveIntValue"+           (Prelude.Maybe Data.Word.Word64)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _UninterpretedOption'positiveIntValue+                 (\ x__ y__ -> x__{_UninterpretedOption'positiveIntValue = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f UninterpretedOption "negativeIntValue"+           (Data.Int.Int64)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _UninterpretedOption'negativeIntValue+                 (\ x__ y__ -> x__{_UninterpretedOption'negativeIntValue = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f UninterpretedOption "maybe'negativeIntValue"+           (Prelude.Maybe Data.Int.Int64)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _UninterpretedOption'negativeIntValue+                 (\ x__ y__ -> x__{_UninterpretedOption'negativeIntValue = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f UninterpretedOption "doubleValue"+           (Prelude.Double)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _UninterpretedOption'doubleValue+                 (\ x__ y__ -> x__{_UninterpretedOption'doubleValue = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f UninterpretedOption "maybe'doubleValue"+           (Prelude.Maybe Prelude.Double)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _UninterpretedOption'doubleValue+                 (\ x__ y__ -> x__{_UninterpretedOption'doubleValue = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f UninterpretedOption "stringValue"+           (Data.ByteString.ByteString)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _UninterpretedOption'stringValue+                 (\ x__ y__ -> x__{_UninterpretedOption'stringValue = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f UninterpretedOption "maybe'stringValue"+           (Prelude.Maybe Data.ByteString.ByteString)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _UninterpretedOption'stringValue+                 (\ x__ y__ -> x__{_UninterpretedOption'stringValue = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f UninterpretedOption "aggregateValue"+           (Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _UninterpretedOption'aggregateValue+                 (\ x__ y__ -> x__{_UninterpretedOption'aggregateValue = y__}))+              (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f UninterpretedOption "maybe'aggregateValue"+           (Prelude.Maybe Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _UninterpretedOption'aggregateValue+                 (\ x__ y__ -> x__{_UninterpretedOption'aggregateValue = y__}))+              Prelude.id+instance Data.Default.Class.Default UninterpretedOption where+        def+          = UninterpretedOption{_UninterpretedOption'name = [],+                                _UninterpretedOption'identifierValue = Prelude.Nothing,+                                _UninterpretedOption'positiveIntValue = Prelude.Nothing,+                                _UninterpretedOption'negativeIntValue = Prelude.Nothing,+                                _UninterpretedOption'doubleValue = Prelude.Nothing,+                                _UninterpretedOption'stringValue = Prelude.Nothing,+                                _UninterpretedOption'aggregateValue = Prelude.Nothing,+                                _UninterpretedOption'_unknownFields = ([])}+instance Data.ProtoLens.Message UninterpretedOption where+        messageName _+          = Data.Text.pack "google.protobuf.UninterpretedOption"+        fieldsByTag+          = let name__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "name"+                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                         Data.ProtoLens.FieldTypeDescriptor UninterpretedOption'NamePart)+                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "name")))+                      :: Data.ProtoLens.FieldDescriptor UninterpretedOption+                identifierValue__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "identifier_value"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) ::+                               (Lens.Labels.Proxy#) "maybe'identifierValue")))+                      :: Data.ProtoLens.FieldDescriptor UninterpretedOption+                positiveIntValue__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "positive_int_value"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.UInt64Field ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Word.Word64)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) ::+                               (Lens.Labels.Proxy#) "maybe'positiveIntValue")))+                      :: Data.ProtoLens.FieldDescriptor UninterpretedOption+                negativeIntValue__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "negative_int_value"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.Int64Field ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) ::+                               (Lens.Labels.Proxy#) "maybe'negativeIntValue")))+                      :: Data.ProtoLens.FieldDescriptor UninterpretedOption+                doubleValue__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "double_value"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.DoubleField ::+                         Data.ProtoLens.FieldTypeDescriptor Prelude.Double)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) ::+                               (Lens.Labels.Proxy#) "maybe'doubleValue")))+                      :: Data.ProtoLens.FieldDescriptor UninterpretedOption+                stringValue__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "string_value"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::+                         Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) ::+                               (Lens.Labels.Proxy#) "maybe'stringValue")))+                      :: Data.ProtoLens.FieldDescriptor UninterpretedOption+                aggregateValue__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "aggregate_value"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+                      (Data.ProtoLens.OptionalField+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) ::+                               (Lens.Labels.Proxy#) "maybe'aggregateValue")))+                      :: Data.ProtoLens.FieldDescriptor UninterpretedOption+              in+              Data.Map.fromList+                [(Data.ProtoLens.Tag 2, name__field_descriptor),+                 (Data.ProtoLens.Tag 3, identifierValue__field_descriptor),+                 (Data.ProtoLens.Tag 4, positiveIntValue__field_descriptor),+                 (Data.ProtoLens.Tag 5, negativeIntValue__field_descriptor),+                 (Data.ProtoLens.Tag 6, doubleValue__field_descriptor),+                 (Data.ProtoLens.Tag 7, stringValue__field_descriptor),+                 (Data.ProtoLens.Tag 8, aggregateValue__field_descriptor)]+        unknownFields+          = Lens.Family2.Unchecked.lens _UninterpretedOption'_unknownFields+              (\ x__ y__ -> x__{_UninterpretedOption'_unknownFields = y__})+{- | Fields :++    * 'Proto.Google.Protobuf.Descriptor_Fields.namePart' @:: Lens' UninterpretedOption'NamePart Data.Text.Text@+    * 'Proto.Google.Protobuf.Descriptor_Fields.isExtension' @:: Lens' UninterpretedOption'NamePart Prelude.Bool@+ -}+data UninterpretedOption'NamePart = UninterpretedOption'NamePart{_UninterpretedOption'NamePart'namePart+                                                                 :: !Data.Text.Text,+                                                                 _UninterpretedOption'NamePart'isExtension+                                                                 :: !Prelude.Bool,+                                                                 _UninterpretedOption'NamePart'_unknownFields+                                                                 :: !Data.ProtoLens.FieldSet}+                                  deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)+instance (Lens.Labels.HasLens' f UninterpretedOption'NamePart x a,+          a ~ b) =>+         Lens.Labels.HasLens f UninterpretedOption'NamePart+           UninterpretedOption'NamePart+           x+           a+           b+         where+        lensOf = Lens.Labels.lensOf'+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f UninterpretedOption'NamePart "namePart"+           (Data.Text.Text)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens _UninterpretedOption'NamePart'namePart+                 (\ x__ y__ -> x__{_UninterpretedOption'NamePart'namePart = y__}))+              Prelude.id+instance Prelude.Functor f =>+         Lens.Labels.HasLens' f UninterpretedOption'NamePart "isExtension"+           (Prelude.Bool)+         where+        lensOf' _+          = (Prelude..)+              (Lens.Family2.Unchecked.lens+                 _UninterpretedOption'NamePart'isExtension+                 (\ x__ y__ ->+                    x__{_UninterpretedOption'NamePart'isExtension = y__}))+              Prelude.id+instance Data.Default.Class.Default UninterpretedOption'NamePart+         where+        def+          = UninterpretedOption'NamePart{_UninterpretedOption'NamePart'namePart+                                           = Data.ProtoLens.fieldDefault,+                                         _UninterpretedOption'NamePart'isExtension =+                                           Data.ProtoLens.fieldDefault,+                                         _UninterpretedOption'NamePart'_unknownFields = ([])}+instance Data.ProtoLens.Message UninterpretedOption'NamePart where+        messageName _+          = Data.Text.pack "google.protobuf.UninterpretedOption.NamePart"+        fieldsByTag+          = let namePart__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "name_part"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+                      (Data.ProtoLens.PlainField Data.ProtoLens.Required+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "namePart")))+                      :: Data.ProtoLens.FieldDescriptor UninterpretedOption'NamePart+                isExtension__field_descriptor+                  = Data.ProtoLens.FieldDescriptor "is_extension"+                      (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+                      (Data.ProtoLens.PlainField Data.ProtoLens.Required+                         (Lens.Labels.lensOf+                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "isExtension")))+                      :: Data.ProtoLens.FieldDescriptor UninterpretedOption'NamePart+              in+              Data.Map.fromList+                [(Data.ProtoLens.Tag 1, namePart__field_descriptor),+                 (Data.ProtoLens.Tag 2, isExtension__field_descriptor)]+        unknownFields+          = Lens.Family2.Unchecked.lens+              _UninterpretedOption'NamePart'_unknownFields+              (\ x__ y__ ->+                 x__{_UninterpretedOption'NamePart'_unknownFields = y__})

@@ -0,0 +1,894 @@+{- This file was auto-generated from google/protobuf/descriptor.proto by the proto-lens-protoc program. -}+{-# LANGUAGE ScopedTypeVariables, DataKinds, TypeFamilies,+  UndecidableInstances, GeneralizedNewtypeDeriving,+  MultiParamTypeClasses, FlexibleContexts, FlexibleInstances,+  PatternSynonyms, MagicHash, NoImplicitPrelude, DataKinds #-}+{-# OPTIONS_GHC -fno-warn-unused-imports#-}+{-# OPTIONS_GHC -fno-warn-duplicate-exports#-}+module Proto.Google.Protobuf.Descriptor_Fields where+import qualified Prelude+import qualified Data.Int+import qualified Data.Word+import qualified Data.ProtoLens+import qualified Data.ProtoLens.Message.Enum+import qualified Data.ProtoLens.Service.Types+import qualified Lens.Family2+import qualified Lens.Family2.Unchecked+import qualified Data.Default.Class+import qualified Data.Text+import qualified Data.Map+import qualified Data.ByteString+import qualified Data.ByteString.Char8+import qualified Lens.Labels+import qualified Text.Read++aggregateValue ::+               forall f s t a b .+                 (Lens.Labels.HasLens f s t "aggregateValue" a b) =>+                 Lens.Family2.LensLike f s t a b+aggregateValue+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "aggregateValue")+allowAlias ::+           forall f s t a b . (Lens.Labels.HasLens f s t "allowAlias" a b) =>+             Lens.Family2.LensLike f s t a b+allowAlias+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "allowAlias")+annotation ::+           forall f s t a b . (Lens.Labels.HasLens f s t "annotation" a b) =>+             Lens.Family2.LensLike f s t a b+annotation+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "annotation")+begin ::+      forall f s t a b . (Lens.Labels.HasLens f s t "begin" a b) =>+        Lens.Family2.LensLike f s t a b+begin+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "begin")+ccEnableArenas ::+               forall f s t a b .+                 (Lens.Labels.HasLens f s t "ccEnableArenas" a b) =>+                 Lens.Family2.LensLike f s t a b+ccEnableArenas+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "ccEnableArenas")+ccGenericServices ::+                  forall f s t a b .+                    (Lens.Labels.HasLens f s t "ccGenericServices" a b) =>+                    Lens.Family2.LensLike f s t a b+ccGenericServices+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "ccGenericServices")+clientStreaming ::+                forall f s t a b .+                  (Lens.Labels.HasLens f s t "clientStreaming" a b) =>+                  Lens.Family2.LensLike f s t a b+clientStreaming+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "clientStreaming")+csharpNamespace ::+                forall f s t a b .+                  (Lens.Labels.HasLens f s t "csharpNamespace" a b) =>+                  Lens.Family2.LensLike f s t a b+csharpNamespace+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "csharpNamespace")+ctype ::+      forall f s t a b . (Lens.Labels.HasLens f s t "ctype" a b) =>+        Lens.Family2.LensLike f s t a b+ctype+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "ctype")+defaultValue ::+             forall f s t a b .+               (Lens.Labels.HasLens f s t "defaultValue" a b) =>+               Lens.Family2.LensLike f s t a b+defaultValue+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "defaultValue")+dependency ::+           forall f s t a b . (Lens.Labels.HasLens f s t "dependency" a b) =>+             Lens.Family2.LensLike f s t a b+dependency+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "dependency")+deprecated ::+           forall f s t a b . (Lens.Labels.HasLens f s t "deprecated" a b) =>+             Lens.Family2.LensLike f s t a b+deprecated+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "deprecated")+doubleValue ::+            forall f s t a b . (Lens.Labels.HasLens f s t "doubleValue" a b) =>+              Lens.Family2.LensLike f s t a b+doubleValue+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "doubleValue")+end ::+    forall f s t a b . (Lens.Labels.HasLens f s t "end" a b) =>+      Lens.Family2.LensLike f s t a b+end+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "end")+enumType ::+         forall f s t a b . (Lens.Labels.HasLens f s t "enumType" a b) =>+           Lens.Family2.LensLike f s t a b+enumType+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "enumType")+extendee ::+         forall f s t a b . (Lens.Labels.HasLens f s t "extendee" a b) =>+           Lens.Family2.LensLike f s t a b+extendee+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "extendee")+extension ::+          forall f s t a b . (Lens.Labels.HasLens f s t "extension" a b) =>+            Lens.Family2.LensLike f s t a b+extension+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "extension")+extensionRange ::+               forall f s t a b .+                 (Lens.Labels.HasLens f s t "extensionRange" a b) =>+                 Lens.Family2.LensLike f s t a b+extensionRange+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "extensionRange")+field ::+      forall f s t a b . (Lens.Labels.HasLens f s t "field" a b) =>+        Lens.Family2.LensLike f s t a b+field+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "field")+file ::+     forall f s t a b . (Lens.Labels.HasLens f s t "file" a b) =>+       Lens.Family2.LensLike f s t a b+file+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "file")+goPackage ::+          forall f s t a b . (Lens.Labels.HasLens f s t "goPackage" a b) =>+            Lens.Family2.LensLike f s t a b+goPackage+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "goPackage")+identifierValue ::+                forall f s t a b .+                  (Lens.Labels.HasLens f s t "identifierValue" a b) =>+                  Lens.Family2.LensLike f s t a b+identifierValue+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "identifierValue")+inputType ::+          forall f s t a b . (Lens.Labels.HasLens f s t "inputType" a b) =>+            Lens.Family2.LensLike f s t a b+inputType+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "inputType")+isExtension ::+            forall f s t a b . (Lens.Labels.HasLens f s t "isExtension" a b) =>+              Lens.Family2.LensLike f s t a b+isExtension+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "isExtension")+javaGenerateEqualsAndHash ::+                          forall f s t a b .+                            (Lens.Labels.HasLens f s t "javaGenerateEqualsAndHash" a b) =>+                            Lens.Family2.LensLike f s t a b+javaGenerateEqualsAndHash+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) ::+         (Lens.Labels.Proxy#) "javaGenerateEqualsAndHash")+javaGenericServices ::+                    forall f s t a b .+                      (Lens.Labels.HasLens f s t "javaGenericServices" a b) =>+                      Lens.Family2.LensLike f s t a b+javaGenericServices+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) ::+         (Lens.Labels.Proxy#) "javaGenericServices")+javaMultipleFiles ::+                  forall f s t a b .+                    (Lens.Labels.HasLens f s t "javaMultipleFiles" a b) =>+                    Lens.Family2.LensLike f s t a b+javaMultipleFiles+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "javaMultipleFiles")+javaOuterClassname ::+                   forall f s t a b .+                     (Lens.Labels.HasLens f s t "javaOuterClassname" a b) =>+                     Lens.Family2.LensLike f s t a b+javaOuterClassname+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "javaOuterClassname")+javaPackage ::+            forall f s t a b . (Lens.Labels.HasLens f s t "javaPackage" a b) =>+              Lens.Family2.LensLike f s t a b+javaPackage+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "javaPackage")+javaStringCheckUtf8 ::+                    forall f s t a b .+                      (Lens.Labels.HasLens f s t "javaStringCheckUtf8" a b) =>+                      Lens.Family2.LensLike f s t a b+javaStringCheckUtf8+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) ::+         (Lens.Labels.Proxy#) "javaStringCheckUtf8")+jsonName ::+         forall f s t a b . (Lens.Labels.HasLens f s t "jsonName" a b) =>+           Lens.Family2.LensLike f s t a b+jsonName+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "jsonName")+jstype ::+       forall f s t a b . (Lens.Labels.HasLens f s t "jstype" a b) =>+         Lens.Family2.LensLike f s t a b+jstype+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "jstype")+label ::+      forall f s t a b . (Lens.Labels.HasLens f s t "label" a b) =>+        Lens.Family2.LensLike f s t a b+label+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "label")+lazy ::+     forall f s t a b . (Lens.Labels.HasLens f s t "lazy" a b) =>+       Lens.Family2.LensLike f s t a b+lazy+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "lazy")+leadingComments ::+                forall f s t a b .+                  (Lens.Labels.HasLens f s t "leadingComments" a b) =>+                  Lens.Family2.LensLike f s t a b+leadingComments+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "leadingComments")+leadingDetachedComments ::+                        forall f s t a b .+                          (Lens.Labels.HasLens f s t "leadingDetachedComments" a b) =>+                          Lens.Family2.LensLike f s t a b+leadingDetachedComments+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) ::+         (Lens.Labels.Proxy#) "leadingDetachedComments")+location ::+         forall f s t a b . (Lens.Labels.HasLens f s t "location" a b) =>+           Lens.Family2.LensLike f s t a b+location+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "location")+mapEntry ::+         forall f s t a b . (Lens.Labels.HasLens f s t "mapEntry" a b) =>+           Lens.Family2.LensLike f s t a b+mapEntry+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "mapEntry")+maybe'aggregateValue ::+                     forall f s t a b .+                       (Lens.Labels.HasLens f s t "maybe'aggregateValue" a b) =>+                       Lens.Family2.LensLike f s t a b+maybe'aggregateValue+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) ::+         (Lens.Labels.Proxy#) "maybe'aggregateValue")+maybe'allowAlias ::+                 forall f s t a b .+                   (Lens.Labels.HasLens f s t "maybe'allowAlias" a b) =>+                   Lens.Family2.LensLike f s t a b+maybe'allowAlias+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'allowAlias")+maybe'begin ::+            forall f s t a b . (Lens.Labels.HasLens f s t "maybe'begin" a b) =>+              Lens.Family2.LensLike f s t a b+maybe'begin+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'begin")+maybe'ccEnableArenas ::+                     forall f s t a b .+                       (Lens.Labels.HasLens f s t "maybe'ccEnableArenas" a b) =>+                       Lens.Family2.LensLike f s t a b+maybe'ccEnableArenas+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) ::+         (Lens.Labels.Proxy#) "maybe'ccEnableArenas")+maybe'ccGenericServices ::+                        forall f s t a b .+                          (Lens.Labels.HasLens f s t "maybe'ccGenericServices" a b) =>+                          Lens.Family2.LensLike f s t a b+maybe'ccGenericServices+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) ::+         (Lens.Labels.Proxy#) "maybe'ccGenericServices")+maybe'clientStreaming ::+                      forall f s t a b .+                        (Lens.Labels.HasLens f s t "maybe'clientStreaming" a b) =>+                        Lens.Family2.LensLike f s t a b+maybe'clientStreaming+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) ::+         (Lens.Labels.Proxy#) "maybe'clientStreaming")+maybe'csharpNamespace ::+                      forall f s t a b .+                        (Lens.Labels.HasLens f s t "maybe'csharpNamespace" a b) =>+                        Lens.Family2.LensLike f s t a b+maybe'csharpNamespace+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) ::+         (Lens.Labels.Proxy#) "maybe'csharpNamespace")+maybe'ctype ::+            forall f s t a b . (Lens.Labels.HasLens f s t "maybe'ctype" a b) =>+              Lens.Family2.LensLike f s t a b+maybe'ctype+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'ctype")+maybe'defaultValue ::+                   forall f s t a b .+                     (Lens.Labels.HasLens f s t "maybe'defaultValue" a b) =>+                     Lens.Family2.LensLike f s t a b+maybe'defaultValue+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'defaultValue")+maybe'deprecated ::+                 forall f s t a b .+                   (Lens.Labels.HasLens f s t "maybe'deprecated" a b) =>+                   Lens.Family2.LensLike f s t a b+maybe'deprecated+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'deprecated")+maybe'doubleValue ::+                  forall f s t a b .+                    (Lens.Labels.HasLens f s t "maybe'doubleValue" a b) =>+                    Lens.Family2.LensLike f s t a b+maybe'doubleValue+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'doubleValue")+maybe'end ::+          forall f s t a b . (Lens.Labels.HasLens f s t "maybe'end" a b) =>+            Lens.Family2.LensLike f s t a b+maybe'end+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'end")+maybe'extendee ::+               forall f s t a b .+                 (Lens.Labels.HasLens f s t "maybe'extendee" a b) =>+                 Lens.Family2.LensLike f s t a b+maybe'extendee+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'extendee")+maybe'goPackage ::+                forall f s t a b .+                  (Lens.Labels.HasLens f s t "maybe'goPackage" a b) =>+                  Lens.Family2.LensLike f s t a b+maybe'goPackage+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'goPackage")+maybe'identifierValue ::+                      forall f s t a b .+                        (Lens.Labels.HasLens f s t "maybe'identifierValue" a b) =>+                        Lens.Family2.LensLike f s t a b+maybe'identifierValue+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) ::+         (Lens.Labels.Proxy#) "maybe'identifierValue")+maybe'inputType ::+                forall f s t a b .+                  (Lens.Labels.HasLens f s t "maybe'inputType" a b) =>+                  Lens.Family2.LensLike f s t a b+maybe'inputType+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'inputType")+maybe'javaGenerateEqualsAndHash ::+                                forall f s t a b .+                                  (Lens.Labels.HasLens f s t "maybe'javaGenerateEqualsAndHash" a+                                     b) =>+                                  Lens.Family2.LensLike f s t a b+maybe'javaGenerateEqualsAndHash+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) ::+         (Lens.Labels.Proxy#) "maybe'javaGenerateEqualsAndHash")+maybe'javaGenericServices ::+                          forall f s t a b .+                            (Lens.Labels.HasLens f s t "maybe'javaGenericServices" a b) =>+                            Lens.Family2.LensLike f s t a b+maybe'javaGenericServices+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) ::+         (Lens.Labels.Proxy#) "maybe'javaGenericServices")+maybe'javaMultipleFiles ::+                        forall f s t a b .+                          (Lens.Labels.HasLens f s t "maybe'javaMultipleFiles" a b) =>+                          Lens.Family2.LensLike f s t a b+maybe'javaMultipleFiles+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) ::+         (Lens.Labels.Proxy#) "maybe'javaMultipleFiles")+maybe'javaOuterClassname ::+                         forall f s t a b .+                           (Lens.Labels.HasLens f s t "maybe'javaOuterClassname" a b) =>+                           Lens.Family2.LensLike f s t a b+maybe'javaOuterClassname+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) ::+         (Lens.Labels.Proxy#) "maybe'javaOuterClassname")+maybe'javaPackage ::+                  forall f s t a b .+                    (Lens.Labels.HasLens f s t "maybe'javaPackage" a b) =>+                    Lens.Family2.LensLike f s t a b+maybe'javaPackage+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'javaPackage")+maybe'javaStringCheckUtf8 ::+                          forall f s t a b .+                            (Lens.Labels.HasLens f s t "maybe'javaStringCheckUtf8" a b) =>+                            Lens.Family2.LensLike f s t a b+maybe'javaStringCheckUtf8+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) ::+         (Lens.Labels.Proxy#) "maybe'javaStringCheckUtf8")+maybe'jsonName ::+               forall f s t a b .+                 (Lens.Labels.HasLens f s t "maybe'jsonName" a b) =>+                 Lens.Family2.LensLike f s t a b+maybe'jsonName+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'jsonName")+maybe'jstype ::+             forall f s t a b .+               (Lens.Labels.HasLens f s t "maybe'jstype" a b) =>+               Lens.Family2.LensLike f s t a b+maybe'jstype+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'jstype")+maybe'label ::+            forall f s t a b . (Lens.Labels.HasLens f s t "maybe'label" a b) =>+              Lens.Family2.LensLike f s t a b+maybe'label+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'label")+maybe'lazy ::+           forall f s t a b . (Lens.Labels.HasLens f s t "maybe'lazy" a b) =>+             Lens.Family2.LensLike f s t a b+maybe'lazy+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'lazy")+maybe'leadingComments ::+                      forall f s t a b .+                        (Lens.Labels.HasLens f s t "maybe'leadingComments" a b) =>+                        Lens.Family2.LensLike f s t a b+maybe'leadingComments+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) ::+         (Lens.Labels.Proxy#) "maybe'leadingComments")+maybe'mapEntry ::+               forall f s t a b .+                 (Lens.Labels.HasLens f s t "maybe'mapEntry" a b) =>+                 Lens.Family2.LensLike f s t a b+maybe'mapEntry+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'mapEntry")+maybe'messageSetWireFormat ::+                           forall f s t a b .+                             (Lens.Labels.HasLens f s t "maybe'messageSetWireFormat" a b) =>+                             Lens.Family2.LensLike f s t a b+maybe'messageSetWireFormat+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) ::+         (Lens.Labels.Proxy#) "maybe'messageSetWireFormat")+maybe'name ::+           forall f s t a b . (Lens.Labels.HasLens f s t "maybe'name" a b) =>+             Lens.Family2.LensLike f s t a b+maybe'name+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'name")+maybe'negativeIntValue ::+                       forall f s t a b .+                         (Lens.Labels.HasLens f s t "maybe'negativeIntValue" a b) =>+                         Lens.Family2.LensLike f s t a b+maybe'negativeIntValue+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) ::+         (Lens.Labels.Proxy#) "maybe'negativeIntValue")+maybe'noStandardDescriptorAccessor ::+                                   forall f s t a b .+                                     (Lens.Labels.HasLens f s t "maybe'noStandardDescriptorAccessor"+                                        a b) =>+                                     Lens.Family2.LensLike f s t a b+maybe'noStandardDescriptorAccessor+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) ::+         (Lens.Labels.Proxy#) "maybe'noStandardDescriptorAccessor")+maybe'number ::+             forall f s t a b .+               (Lens.Labels.HasLens f s t "maybe'number" a b) =>+               Lens.Family2.LensLike f s t a b+maybe'number+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'number")+maybe'objcClassPrefix ::+                      forall f s t a b .+                        (Lens.Labels.HasLens f s t "maybe'objcClassPrefix" a b) =>+                        Lens.Family2.LensLike f s t a b+maybe'objcClassPrefix+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) ::+         (Lens.Labels.Proxy#) "maybe'objcClassPrefix")+maybe'oneofIndex ::+                 forall f s t a b .+                   (Lens.Labels.HasLens f s t "maybe'oneofIndex" a b) =>+                   Lens.Family2.LensLike f s t a b+maybe'oneofIndex+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'oneofIndex")+maybe'optimizeFor ::+                  forall f s t a b .+                    (Lens.Labels.HasLens f s t "maybe'optimizeFor" a b) =>+                    Lens.Family2.LensLike f s t a b+maybe'optimizeFor+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'optimizeFor")+maybe'options ::+              forall f s t a b .+                (Lens.Labels.HasLens f s t "maybe'options" a b) =>+                Lens.Family2.LensLike f s t a b+maybe'options+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'options")+maybe'outputType ::+                 forall f s t a b .+                   (Lens.Labels.HasLens f s t "maybe'outputType" a b) =>+                   Lens.Family2.LensLike f s t a b+maybe'outputType+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'outputType")+maybe'package ::+              forall f s t a b .+                (Lens.Labels.HasLens f s t "maybe'package" a b) =>+                Lens.Family2.LensLike f s t a b+maybe'package+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'package")+maybe'packed ::+             forall f s t a b .+               (Lens.Labels.HasLens f s t "maybe'packed" a b) =>+               Lens.Family2.LensLike f s t a b+maybe'packed+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'packed")+maybe'positiveIntValue ::+                       forall f s t a b .+                         (Lens.Labels.HasLens f s t "maybe'positiveIntValue" a b) =>+                         Lens.Family2.LensLike f s t a b+maybe'positiveIntValue+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) ::+         (Lens.Labels.Proxy#) "maybe'positiveIntValue")+maybe'pyGenericServices ::+                        forall f s t a b .+                          (Lens.Labels.HasLens f s t "maybe'pyGenericServices" a b) =>+                          Lens.Family2.LensLike f s t a b+maybe'pyGenericServices+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) ::+         (Lens.Labels.Proxy#) "maybe'pyGenericServices")+maybe'serverStreaming ::+                      forall f s t a b .+                        (Lens.Labels.HasLens f s t "maybe'serverStreaming" a b) =>+                        Lens.Family2.LensLike f s t a b+maybe'serverStreaming+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) ::+         (Lens.Labels.Proxy#) "maybe'serverStreaming")+maybe'sourceCodeInfo ::+                     forall f s t a b .+                       (Lens.Labels.HasLens f s t "maybe'sourceCodeInfo" a b) =>+                       Lens.Family2.LensLike f s t a b+maybe'sourceCodeInfo+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) ::+         (Lens.Labels.Proxy#) "maybe'sourceCodeInfo")+maybe'sourceFile ::+                 forall f s t a b .+                   (Lens.Labels.HasLens f s t "maybe'sourceFile" a b) =>+                   Lens.Family2.LensLike f s t a b+maybe'sourceFile+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'sourceFile")+maybe'start ::+            forall f s t a b . (Lens.Labels.HasLens f s t "maybe'start" a b) =>+              Lens.Family2.LensLike f s t a b+maybe'start+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'start")+maybe'stringValue ::+                  forall f s t a b .+                    (Lens.Labels.HasLens f s t "maybe'stringValue" a b) =>+                    Lens.Family2.LensLike f s t a b+maybe'stringValue+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'stringValue")+maybe'syntax ::+             forall f s t a b .+               (Lens.Labels.HasLens f s t "maybe'syntax" a b) =>+               Lens.Family2.LensLike f s t a b+maybe'syntax+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'syntax")+maybe'trailingComments ::+                       forall f s t a b .+                         (Lens.Labels.HasLens f s t "maybe'trailingComments" a b) =>+                         Lens.Family2.LensLike f s t a b+maybe'trailingComments+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) ::+         (Lens.Labels.Proxy#) "maybe'trailingComments")+maybe'type' ::+            forall f s t a b . (Lens.Labels.HasLens f s t "maybe'type'" a b) =>+              Lens.Family2.LensLike f s t a b+maybe'type'+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'type'")+maybe'typeName ::+               forall f s t a b .+                 (Lens.Labels.HasLens f s t "maybe'typeName" a b) =>+                 Lens.Family2.LensLike f s t a b+maybe'typeName+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'typeName")+maybe'weak ::+           forall f s t a b . (Lens.Labels.HasLens f s t "maybe'weak" a b) =>+             Lens.Family2.LensLike f s t a b+maybe'weak+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'weak")+messageSetWireFormat ::+                     forall f s t a b .+                       (Lens.Labels.HasLens f s t "messageSetWireFormat" a b) =>+                       Lens.Family2.LensLike f s t a b+messageSetWireFormat+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) ::+         (Lens.Labels.Proxy#) "messageSetWireFormat")+messageType ::+            forall f s t a b . (Lens.Labels.HasLens f s t "messageType" a b) =>+              Lens.Family2.LensLike f s t a b+messageType+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "messageType")+method ::+       forall f s t a b . (Lens.Labels.HasLens f s t "method" a b) =>+         Lens.Family2.LensLike f s t a b+method+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "method")+name ::+     forall f s t a b . (Lens.Labels.HasLens f s t "name" a b) =>+       Lens.Family2.LensLike f s t a b+name+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "name")+namePart ::+         forall f s t a b . (Lens.Labels.HasLens f s t "namePart" a b) =>+           Lens.Family2.LensLike f s t a b+namePart+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "namePart")+negativeIntValue ::+                 forall f s t a b .+                   (Lens.Labels.HasLens f s t "negativeIntValue" a b) =>+                   Lens.Family2.LensLike f s t a b+negativeIntValue+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "negativeIntValue")+nestedType ::+           forall f s t a b . (Lens.Labels.HasLens f s t "nestedType" a b) =>+             Lens.Family2.LensLike f s t a b+nestedType+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "nestedType")+noStandardDescriptorAccessor ::+                             forall f s t a b .+                               (Lens.Labels.HasLens f s t "noStandardDescriptorAccessor" a b) =>+                               Lens.Family2.LensLike f s t a b+noStandardDescriptorAccessor+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) ::+         (Lens.Labels.Proxy#) "noStandardDescriptorAccessor")+number ::+       forall f s t a b . (Lens.Labels.HasLens f s t "number" a b) =>+         Lens.Family2.LensLike f s t a b+number+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "number")+objcClassPrefix ::+                forall f s t a b .+                  (Lens.Labels.HasLens f s t "objcClassPrefix" a b) =>+                  Lens.Family2.LensLike f s t a b+objcClassPrefix+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "objcClassPrefix")+oneofDecl ::+          forall f s t a b . (Lens.Labels.HasLens f s t "oneofDecl" a b) =>+            Lens.Family2.LensLike f s t a b+oneofDecl+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "oneofDecl")+oneofIndex ::+           forall f s t a b . (Lens.Labels.HasLens f s t "oneofIndex" a b) =>+             Lens.Family2.LensLike f s t a b+oneofIndex+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "oneofIndex")+optimizeFor ::+            forall f s t a b . (Lens.Labels.HasLens f s t "optimizeFor" a b) =>+              Lens.Family2.LensLike f s t a b+optimizeFor+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "optimizeFor")+options ::+        forall f s t a b . (Lens.Labels.HasLens f s t "options" a b) =>+          Lens.Family2.LensLike f s t a b+options+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "options")+outputType ::+           forall f s t a b . (Lens.Labels.HasLens f s t "outputType" a b) =>+             Lens.Family2.LensLike f s t a b+outputType+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "outputType")+package ::+        forall f s t a b . (Lens.Labels.HasLens f s t "package" a b) =>+          Lens.Family2.LensLike f s t a b+package+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "package")+packed ::+       forall f s t a b . (Lens.Labels.HasLens f s t "packed" a b) =>+         Lens.Family2.LensLike f s t a b+packed+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "packed")+path ::+     forall f s t a b . (Lens.Labels.HasLens f s t "path" a b) =>+       Lens.Family2.LensLike f s t a b+path+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "path")+positiveIntValue ::+                 forall f s t a b .+                   (Lens.Labels.HasLens f s t "positiveIntValue" a b) =>+                   Lens.Family2.LensLike f s t a b+positiveIntValue+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "positiveIntValue")+publicDependency ::+                 forall f s t a b .+                   (Lens.Labels.HasLens f s t "publicDependency" a b) =>+                   Lens.Family2.LensLike f s t a b+publicDependency+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "publicDependency")+pyGenericServices ::+                  forall f s t a b .+                    (Lens.Labels.HasLens f s t "pyGenericServices" a b) =>+                    Lens.Family2.LensLike f s t a b+pyGenericServices+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "pyGenericServices")+reservedName ::+             forall f s t a b .+               (Lens.Labels.HasLens f s t "reservedName" a b) =>+               Lens.Family2.LensLike f s t a b+reservedName+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "reservedName")+reservedRange ::+              forall f s t a b .+                (Lens.Labels.HasLens f s t "reservedRange" a b) =>+                Lens.Family2.LensLike f s t a b+reservedRange+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "reservedRange")+serverStreaming ::+                forall f s t a b .+                  (Lens.Labels.HasLens f s t "serverStreaming" a b) =>+                  Lens.Family2.LensLike f s t a b+serverStreaming+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "serverStreaming")+service ::+        forall f s t a b . (Lens.Labels.HasLens f s t "service" a b) =>+          Lens.Family2.LensLike f s t a b+service+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "service")+sourceCodeInfo ::+               forall f s t a b .+                 (Lens.Labels.HasLens f s t "sourceCodeInfo" a b) =>+                 Lens.Family2.LensLike f s t a b+sourceCodeInfo+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "sourceCodeInfo")+sourceFile ::+           forall f s t a b . (Lens.Labels.HasLens f s t "sourceFile" a b) =>+             Lens.Family2.LensLike f s t a b+sourceFile+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "sourceFile")+span ::+     forall f s t a b . (Lens.Labels.HasLens f s t "span" a b) =>+       Lens.Family2.LensLike f s t a b+span+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "span")+start ::+      forall f s t a b . (Lens.Labels.HasLens f s t "start" a b) =>+        Lens.Family2.LensLike f s t a b+start+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "start")+stringValue ::+            forall f s t a b . (Lens.Labels.HasLens f s t "stringValue" a b) =>+              Lens.Family2.LensLike f s t a b+stringValue+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "stringValue")+syntax ::+       forall f s t a b . (Lens.Labels.HasLens f s t "syntax" a b) =>+         Lens.Family2.LensLike f s t a b+syntax+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "syntax")+trailingComments ::+                 forall f s t a b .+                   (Lens.Labels.HasLens f s t "trailingComments" a b) =>+                   Lens.Family2.LensLike f s t a b+trailingComments+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "trailingComments")+type' ::+      forall f s t a b . (Lens.Labels.HasLens f s t "type'" a b) =>+        Lens.Family2.LensLike f s t a b+type'+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "type'")+typeName ::+         forall f s t a b . (Lens.Labels.HasLens f s t "typeName" a b) =>+           Lens.Family2.LensLike f s t a b+typeName+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "typeName")+uninterpretedOption ::+                    forall f s t a b .+                      (Lens.Labels.HasLens f s t "uninterpretedOption" a b) =>+                      Lens.Family2.LensLike f s t a b+uninterpretedOption+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) ::+         (Lens.Labels.Proxy#) "uninterpretedOption")+value ::+      forall f s t a b . (Lens.Labels.HasLens f s t "value" a b) =>+        Lens.Family2.LensLike f s t a b+value+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "value")+weak ::+     forall f s t a b . (Lens.Labels.HasLens f s t "weak" a b) =>+       Lens.Family2.LensLike f s t a b+weak+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "weak")+weakDependency ::+               forall f s t a b .+                 (Lens.Labels.HasLens f s t "weakDependency" a b) =>+                 Lens.Family2.LensLike f s t a b+weakDependency+  = Lens.Labels.lensOf+      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "weakDependency")